@monoes/monomindcli 1.14.6 → 1.15.0

package/dist/src/commands/hooks.js

@@ -1,285 +1,66 @@
 /**
  * CLI Hooks Command
  * Self-learning hooks system for intelligent workflow automation
+ *
+ * This file is the main registration entry point.
+ * Commands are extracted to sub-modules (ARCH-1):
+ *   - hooks-core-commands.ts    — pre/post edit and command hooks
+ *   - hooks-routing-commands.ts — route/explain/pretrain/build-agents/metrics/transfer/list
+ *   - hooks-workers.ts          — intelligence and worker commands
+ *   - hooks-coverage-commands.ts — coverage-aware routing
+ *   - hooks-extended-commands.ts — token optimize, model routing, agent teams
  */
 import { output } from '../output.js';
-import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { storeCommand } from './transfer-store.js';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Read coverage data from disk. Checks these locations in order:
- * 1. coverage/coverage-summary.json (Jest/Istanbul)
- * 2. coverage/lcov.info (lcov format)
- * 3. .nyc_output/out.json (nyc)
- */
-function readCoverageFromDisk() {
-    const cwd = process.cwd();
-    const noData = {
-        found: false,
-        source: 'none',
-        entries: [],
-        summary: { totalFiles: 0, overallLineCoverage: 0, overallBranchCoverage: 0, overallFunctionCoverage: 0, overallStatementCoverage: 0 },
-    };
-    // 1. Try coverage-summary.json (Jest/Istanbul)
-    for (const relPath of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
-        const summaryPath = join(cwd, relPath);
-        if (existsSync(summaryPath)) {
-            try {
-                if (statSync(summaryPath).size <= 4_194_304) {
-                    const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
-                    return parseCoverageSummaryJson(raw, relPath);
-                }
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 2. Try lcov.info
-    for (const relPath of ['coverage/lcov.info', 'lcov.info']) {
-        const lcovPath = join(cwd, relPath);
-        if (existsSync(lcovPath)) {
-            try {
-                if (statSync(lcovPath).size <= 8_388_608) {
-                    const raw = readFileSync(lcovPath, 'utf-8');
-                    return parseLcovInfo(raw, relPath);
-                }
-            }
-            catch {
-                // malformed, try next
-            }
-        }
-    }
-    // 3. Try .nyc_output/out.json
-    const nycPath = join(cwd, '.nyc_output', 'out.json');
-    if (existsSync(nycPath)) {
-        try {
-            if (statSync(nycPath).size <= 4_194_304) {
-                const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
-                return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
-            }
-        }
-        catch {
-            // malformed
-        }
-    }
-    return noData;
-}
-function parseCoverageSummaryJson(data, source) {
-    const entries = [];
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    for (const [filePath, metrics] of Object.entries(data)) {
-        if (filePath === 'total')
-            continue;
-        const m = metrics;
-        if (!m || typeof m !== 'object')
-            continue;
-        const linePct = m.lines?.pct ?? (m.lines?.covered != null ? ((m.lines?.covered ?? 0) / Math.max(m.lines?.total ?? 1, 1)) * 100 : 0);
-        const branchPct = m.branches?.pct ?? (m.branches?.total ? ((m.branches?.covered ?? 0) / m.branches.total) * 100 : 100);
-        const funcPct = m.functions?.pct ?? (m.functions?.total ? ((m.functions?.covered ?? 0) / m.functions.total) * 100 : 100);
-        const stmtPct = m.statements?.pct ?? (m.statements?.total ? ((m.statements?.covered ?? 0) / m.statements.total) * 100 : 100);
-        entries.push({ filePath, lines: linePct, branches: branchPct, functions: funcPct, statements: stmtPct });
-        totalLines += m.lines?.total ?? 0;
-        coveredLines += m.lines?.covered ?? 0;
-        totalBranches += m.branches?.total ?? 0;
-        coveredBranches += m.branches?.covered ?? 0;
-        totalFunctions += m.functions?.total ?? 0;
-        coveredFunctions += m.functions?.covered ?? 0;
-        totalStatements += m.statements?.total ?? 0;
-        coveredStatements += m.statements?.covered ?? 0;
-    }
-    // Also read the total key if present
-    const total = data['total'];
-    const overallLine = total?.lines?.pct ?? (totalLines > 0 ? (coveredLines / totalLines) * 100 : 0);
-    const overallBranch = total?.branches?.pct ?? (totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 0);
-    const overallFunction = total?.functions?.pct ?? (totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0);
-    const overallStatement = total?.statements?.pct ?? (totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0);
-    // Sort by lowest line coverage
-    entries.sort((a, b) => a.lines - b.lines);
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: overallLine,
-            overallBranchCoverage: overallBranch,
-            overallFunctionCoverage: overallFunction,
-            overallStatementCoverage: overallStatement,
-        },
-    };
-}
-function parseLcovInfo(raw, source) {
-    const entries = [];
-    let currentFile = '';
-    let linesHit = 0, linesFound = 0;
-    let branchesHit = 0, branchesFound = 0;
-    let functionsHit = 0, functionsFound = 0;
-    let totalLines = 0, coveredLines = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalStatements = 0, coveredStatements = 0;
-    const flushRecord = () => {
-        if (currentFile) {
-            entries.push({
-                filePath: currentFile,
-                lines: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-                branches: branchesFound > 0 ? (branchesHit / branchesFound) * 100 : 100,
-                functions: functionsFound > 0 ? (functionsHit / functionsFound) * 100 : 100,
-                statements: linesFound > 0 ? (linesHit / linesFound) * 100 : 0,
-            });
-            totalLines += linesFound;
-            coveredLines += linesHit;
-            totalBranches += branchesFound;
-            coveredBranches += branchesHit;
-            totalFunctions += functionsFound;
-            coveredFunctions += functionsHit;
-            totalStatements += linesFound;
-            coveredStatements += linesHit;
-        }
-    };
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('SF:')) {
-            currentFile = trimmed.slice(3);
-            linesHit = 0;
-            linesFound = 0;
-            branchesHit = 0;
-            branchesFound = 0;
-            functionsHit = 0;
-            functionsFound = 0;
-        }
-        else if (trimmed.startsWith('LH:')) {
-            linesHit = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('LF:')) {
-            linesFound = parseInt(trimmed.slice(3), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRH:')) {
-            branchesHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('BRF:')) {
-            branchesFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNH:')) {
-            functionsHit = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed.startsWith('FNF:')) {
-            functionsFound = parseInt(trimmed.slice(4), 10) || 0;
-        }
-        else if (trimmed === 'end_of_record') {
-            flushRecord();
-            currentFile = '';
-        }
-    }
-    flushRecord();
-    entries.sort((a, b) => a.lines - b.lines);
-    return {
-        found: true,
-        source,
-        entries,
-        summary: {
-            totalFiles: entries.length,
-            overallLineCoverage: totalLines > 0 ? (coveredLines / totalLines) * 100 : 0,
-            overallBranchCoverage: totalBranches > 0 ? (coveredBranches / totalBranches) * 100 : 100,
-            overallFunctionCoverage: totalFunctions > 0 ? (coveredFunctions / totalFunctions) * 100 : 0,
-            overallStatementCoverage: totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0,
-        },
-    };
-}
-/**
- * Classify a coverage gap by priority type based on coverage percentage and threshold
- */
-function classifyCoverageGap(coveragePct, threshold) {
-    if (coveragePct < threshold * 0.25)
-        return { gapType: 'critical', priority: 10 };
-    if (coveragePct < threshold * 0.5)
-        return { gapType: 'high', priority: 7 };
-    if (coveragePct < threshold * 0.75)
-        return { gapType: 'medium', priority: 5 };
-    if (coveragePct < threshold)
-        return { gapType: 'low', priority: 3 };
-    return { gapType: 'ok', priority: 0 };
-}
-/**
- * Suggest agents for a file based on its path
- */
-function suggestAgentsForFile(filePath) {
-    const lower = filePath.toLowerCase();
-    if (lower.includes('test') || lower.includes('spec'))
-        return ['tester'];
-    if (lower.includes('security') || lower.includes('auth'))
-        return ['security-auditor', 'tester'];
-    if (lower.includes('api') || lower.includes('route') || lower.includes('controller'))
-        return ['coder', 'tester'];
-    if (lower.includes('model') || lower.includes('schema') || lower.includes('entity'))
-        return ['coder', 'tester'];
-    return ['tester', 'coder'];
-}
-// Hook types
-const HOOK_TYPES = [
-    { value: 'pre-edit', label: 'Pre-Edit', hint: 'Get context before editing files' },
-    { value: 'post-edit', label: 'Post-Edit', hint: 'Record editing outcomes' },
-    { value: 'pre-command', label: 'Pre-Command', hint: 'Assess risk before commands' },
-    { value: 'post-command', label: 'Post-Command', hint: 'Record command outcomes' },
-    { value: 'route', label: 'Route', hint: 'Route tasks to optimal agents' },
-    { value: 'explain', label: 'Explain', hint: 'Explain routing decisions' }
-];
-// Agent routing options
-const AGENT_TYPES = [
-    'coder', 'researcher', 'tester', 'reviewer', 'architect',
-    'security-architect', 'security-auditor', 'memory-specialist',
-    'swarm-specialist', 'performance-engineer', 'core-architect',
-    'test-architect', 'coordinator', 'analyst', 'optimizer'
-];
-// Pre-edit subcommand
-const preEditCommand = {
-    name: 'pre-edit',
-    description: 'Get context and agent suggestions before editing a file',
+import { intelligenceCommand, workerCommand } from './hooks-workers.js';
+import { coverageRouteCommand, coverageSuggestCommand, coverageGapsCommand, progressHookCommand, statuslineCommand, } from './hooks-coverage-commands.js';
+import { tokenOptimizeCommand, modelRouteCommand, modelOutcomeCommand, modelStatsCommand, teammateIdleCommand, taskCompletedCommand, 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
+const preTaskCommand = {
+    name: 'pre-task',
+    description: 'Record task start and get agent suggestions',
     options: [
         {
-            name: 'file',
-            short: 'f',
-            description: 'File path to edit',
-            type: 'string',
-            required: false
+            name: 'task-id',
+            short: 'i',
+            description: 'Unique task identifier (auto-generated if omitted)',
+            type: 'string'
         },
         {
-            name: 'operation',
-            short: 'o',
-            description: 'Type of edit operation (create, update, delete, refactor)',
+            name: 'description',
+            short: 'd',
+            description: 'Task description',
             type: 'string',
-            default: 'update'
+            required: true
         },
         {
-            name: 'context',
-            short: 'c',
-            description: 'Additional context about the edit',
-            type: 'string'
+            name: 'auto-spawn',
+            short: 'a',
+            description: 'Auto-spawn suggested agents',
+            type: 'boolean',
+            default: false
         }
     ],
     examples: [
-        { command: 'monomind hooks pre-edit -f src/utils.ts', description: 'Get context before editing' },
-        { command: 'monomind hooks pre-edit -f src/api.ts -o refactor', description: 'Pre-edit with operation type' }
+        { command: 'monomind hooks pre-task -i task-123 -d "Fix auth bug"', description: 'Record task start' },
+        { command: 'monomind hooks pre-task -i task-456 -d "Implement feature" --auto-spawn', description: 'With auto-spawn' }
     ],
     action: async (ctx) => {
-        // Default file to 'unknown' for backward compatibility (env var may be empty)
-        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
-        const operation = ctx.flags.operation || 'update';
-        output.printInfo(`Analyzing context for: ${output.highlight(filePath)}`);
+        const taskId = ctx.flags['task-id'] || `task-${Date.now().toString(36)}`;
+        const description = ctx.args[0] || ctx.flags.description;
+        if (!description) {
+            output.printError('Description is required: --description "your task"');
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Starting task: ${output.highlight(taskId)}`);
         try {
-            // Call MCP tool for pre-edit hook
-            const result = await callMCPTool('hooks_pre-edit', {
-                filePath,
-                operation,
-                context: ctx.flags.context,
-                includePatterns: true,
-                includeRisks: true,
+            const result = await callMCPTool('hooks_pre-task', {
+                taskId,
+                description,
+                autoSpawn: ctx.flags['auto-spawn'] || false,
+                timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -287,47 +68,38 @@ const preEditCommand = {
             }
             output.writeln();
             output.printBox([
-                `File: ${result.filePath}`,
-                `Operation: ${result.operation}`,
-                `Type: ${result.context.fileType}`,
-                `Exists: ${result.context.fileExists ? 'Yes' : 'No'}`
-            ].join('\n'), 'File Context');
-            if (result.context.suggestedAgents.length > 0) {
+                `Task ID: ${result.taskId}`,
+                `Description: ${result.description}`,
+                `Complexity: ${result.complexity.toUpperCase()}`,
+                `Est. Duration: ${result.estimatedDuration}`
+            ].join('\n'), 'Task Registered');
+            if (result.suggestedAgents.length > 0) {
                 output.writeln();
                 output.writeln(output.bold('Suggested Agents'));
-                output.printList(result.context.suggestedAgents.map(a => output.highlight(a)));
-            }
-            if (result.context.relatedFiles.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Related Files'));
-                output.printList(result.context.relatedFiles.slice(0, 5).map(f => output.dim(f)));
-            }
-            if (result.context.patterns.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Learned Patterns'));
                 output.printTable({
                     columns: [
-                        { key: 'pattern', header: 'Pattern', width: 40 },
-                        { key: 'confidence', header: 'Confidence', width: 12, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(1)}%` }
+                        { key: 'type', header: 'Agent Type', width: 20 },
+                        { key: 'confidence', header: 'Confidence', width: 12, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(1)}%` },
+                        { key: 'reason', header: 'Reason', width: 35 }
                     ],
-                    data: result.context.patterns
+                    data: result.suggestedAgents
                 });
             }
-            if (result.context.risks.length > 0) {
+            if (result.risks.length > 0) {
                 output.writeln();
                 output.writeln(output.bold(output.error('Potential Risks')));
-                output.printList(result.context.risks.map(r => output.warning(r)));
+                output.printList(result.risks.map(r => output.warning(r)));
             }
             if (result.recommendations.length > 0) {
                 output.writeln();
                 output.writeln(output.bold('Recommendations'));
-                output.printList(result.recommendations.map(r => output.success(`• ${r}`)));
+                output.printList(result.recommendations);
             }
             return { success: true, data: result };
         }
         catch (error) {
             if (error instanceof MCPClientError) {
-                output.printError(`Pre-edit hook failed: ${error.message}`);
+                output.printError(`Pre-task hook failed: ${error.message}`);
             }
             else {
                 output.printError(`Unexpected error: ${String(error)}`);
@@ -336,66 +108,57 @@ const preEditCommand = {
         }
     }
 };
-// Post-edit subcommand
-const postEditCommand = {
-    name: 'post-edit',
-    description: 'Record editing outcome for learning',
+// Post-task subcommand
+const postTaskCommand = {
+    name: 'post-task',
+    description: 'Record task completion for learning',
     options: [
         {
-            name: 'file',
-            short: 'f',
-            description: 'File path that was edited',
+            name: 'task-id',
+            short: 'i',
+            description: 'Task identifier',
             type: 'string',
-            required: false
+            required: true
         },
         {
             name: 'success',
             short: 's',
-            description: 'Whether the edit was successful',
+            description: 'Whether the task succeeded',
             type: 'boolean',
             required: false
         },
+        {
+            name: 'duration',
+            short: 'd',
+            description: 'Task duration in milliseconds',
+            type: 'number'
+        },
         {
             name: 'outcome',
             short: 'o',
             description: 'Outcome description',
             type: 'string'
-        },
-        {
-            name: 'metrics',
-            short: 'm',
-            description: 'Performance metrics (e.g., "time:500ms,quality:0.95")',
-            type: 'string'
         }
     ],
     examples: [
-        { command: 'monomind hooks post-edit -f src/utils.ts --success true', description: 'Record successful edit' },
-        { command: 'monomind hooks post-edit -f src/api.ts --success false -o "Type error"', description: 'Record failed edit' }
+        { command: 'monomind hooks post-task -i task-123 --success true', description: 'Record successful task' },
+        { command: 'monomind hooks post-task -i task-456 --success false -o "Build failed"', description: 'Record failed task' }
     ],
     action: async (ctx) => {
-        // Default file to 'unknown' for backward compatibility (env var may be empty)
-        const filePath = ctx.args[0] || ctx.flags.file || 'unknown';
-        // Default success to true for backward compatibility (PostToolUse = success, PostToolUseFailure = failure)
+        const taskId = ctx.args[0] || ctx.flags['task-id'];
+        // Default success to true for backward compatibility
         const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
-        output.printInfo(`Recording outcome for: ${output.highlight(filePath)}`);
+        if (!taskId) {
+            output.printError('Task ID is required. Use --task-id or -i flag.');
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Recording task completion: ${output.highlight(taskId)}`);
         try {
-            // Parse metrics if provided
-            const metrics = {};
-            if (ctx.flags.metrics) {
-                const metricsStr = ctx.flags.metrics;
-                metricsStr.split(',').forEach(pair => {
-                    const [key, value] = pair.split(':');
-                    if (key && value) {
-                        metrics[key.trim()] = parseFloat(value);
-                    }
-                });
-            }
-            // Call MCP tool for post-edit hook
-            const result = await callMCPTool('hooks_post-edit', {
-                filePath,
+            const result = await callMCPTool('hooks_post-task', {
+                taskId,
                 success,
+                duration: ctx.flags.duration,
                 outcome: ctx.flags.outcome,
-                metrics,
                 timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
@@ -403,27 +166,23 @@ const postEditCommand = {
                 return { success: true, data: result };
             }
             output.writeln();
-            output.printSuccess(`Outcome recorded for ${filePath}`);
+            output.printSuccess(`Task ${taskId} recorded as ${success ? 'successful' : 'failed'}`);
             if (result.learningUpdates) {
                 output.writeln();
-                output.writeln(output.bold('Learning Updates'));
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 15, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Patterns Updated', value: result.learningUpdates.patternsUpdated },
-                        { metric: 'Confidence Adjusted', value: result.learningUpdates.confidenceAdjusted },
-                        { metric: 'New Patterns', value: result.learningUpdates.newPatterns }
-                    ]
-                });
+                output.writeln(output.dim(`Agent patterns updated: ${result.learningUpdates.agentPatternsUpdated}`));
+                output.writeln(output.dim(`Strategies learned: ${result.learningUpdates.taskStrategiesLearned}`));
+                output.writeln(output.dim(`Complexity model: ${result.learningUpdates.complexityModelUpdated ? 'Updated' : 'No change'}`));
+            }
+            if (result.nextRecommendations && result.nextRecommendations.length > 0) {
+                output.writeln();
+                output.writeln(output.bold('Recommendations for Next Task'));
+                output.printList(result.nextRecommendations);
             }
             return { success: true, data: result };
         }
         catch (error) {
             if (error instanceof MCPClientError) {
-                output.printError(`Post-edit hook failed: ${error.message}`);
+                output.printError(`Post-task hook failed: ${error.message}`);
             }
             else {
                 output.printError(`Unexpected error: ${String(error)}`);
@@ -432,94 +191,62 @@ const postEditCommand = {
         }
     }
 };
-// Pre-command subcommand
-const preCommandCommand = {
-    name: 'pre-command',
-    description: 'Assess risk before executing a command',
+// Session-end subcommand
+const sessionEndCommand = {
+    name: 'session-end',
+    description: 'End current session and persist state',
     options: [
         {
-            name: 'command',
-            short: 'c',
-            description: 'Command to execute',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'dry-run',
-            short: 'd',
-            description: 'Only analyze, do not execute',
+            name: 'save-state',
+            short: 's',
+            description: 'Save session state for later restoration',
             type: 'boolean',
             default: true
         }
     ],
     examples: [
-        { command: 'monomind hooks pre-command -c "rm -rf dist"', description: 'Assess command risk' },
-        { command: 'monomind hooks pre-command -c "npm install lodash"', description: 'Check package install' }
+        { command: 'monomind hooks session-end', description: 'End and save session' },
+        { command: 'monomind hooks session-end --save-state false', description: 'End without saving' }
     ],
     action: async (ctx) => {
-        const command = ctx.args[0] || ctx.flags.command;
-        if (!command) {
-            output.printError('Command is required. Use --command or -c flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Analyzing command: ${output.highlight(command)}`);
+        output.printInfo('Ending session...');
         try {
-            // Call MCP tool for pre-command hook
-            const result = await callMCPTool('hooks_pre-command', {
-                command,
-                includeAlternatives: true,
+            const result = await callMCPTool('hooks_session-end', {
+                saveState: ctx.flags['save-state'] ?? true,
+                timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
             }
             output.writeln();
-            // Risk level indicator
-            let riskIndicator;
-            switch (result.riskLevel) {
-                case 'critical':
-                    riskIndicator = output.error('CRITICAL');
-                    break;
-                case 'high':
-                    riskIndicator = output.error('HIGH');
-                    break;
-                case 'medium':
-                    riskIndicator = output.warning('MEDIUM');
-                    break;
-                default:
-                    riskIndicator = output.success('LOW');
-            }
-            output.printBox([
-                `Risk Level: ${riskIndicator}`,
-                `Should Proceed: ${result.shouldProceed ? output.success('Yes') : output.error('No')}`
-            ].join('\n'), 'Risk Assessment');
-            if (result.risks.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Identified Risks'));
-                output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Type', width: 15 },
-                        { key: 'severity', header: 'Severity', width: 10 },
-                        { key: 'description', header: 'Description', width: 40 }
-                    ],
-                    data: result.risks
-                });
-            }
-            if (result.safeAlternatives && result.safeAlternatives.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Safe Alternatives'));
-                output.printList(result.safeAlternatives.map(a => output.success(a)));
-            }
-            if (result.recommendations.length > 0) {
+            output.printSuccess(`Session ${result.sessionId} ended`);
+            output.writeln();
+            output.writeln(output.bold('Session Summary'));
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 25 },
+                    { key: 'value', header: 'Value', width: 15, align: 'right' }
+                ],
+                data: [
+                    { metric: 'Duration', value: `${(result.duration / 1000 / 60).toFixed(1)} min` },
+                    { metric: 'Tasks Executed', value: result.summary.tasksExecuted },
+                    { metric: 'Tasks Succeeded', value: output.success(String(result.summary.tasksSucceeded)) },
+                    { metric: 'Tasks Failed', value: output.error(String(result.summary.tasksFailed)) },
+                    { metric: 'Commands Executed', value: result.summary.commandsExecuted },
+                    { metric: 'Files Modified', value: result.summary.filesModified },
+                    { metric: 'Agents Spawned', value: result.summary.agentsSpawned }
+                ]
+            });
+            if (result.statePath) {
                 output.writeln();
-                output.writeln(output.bold('Recommendations'));
-                output.printList(result.recommendations);
+                output.writeln(output.dim(`State saved to: ${result.statePath}`));
             }
             return { success: true, data: result };
         }
         catch (error) {
             if (error instanceof MCPClientError) {
-                output.printError(`Pre-command hook failed: ${error.message}`);
+                output.printError(`Session-end hook failed: ${error.message}`);
             }
             else {
                 output.printError(`Unexpected error: ${String(error)}`);
@@ -528,59 +255,45 @@ const preCommandCommand = {
         }
     }
 };
-// Post-command subcommand
-const postCommandCommand = {
-    name: 'post-command',
-    description: 'Record command execution outcome',
+// Session-restore subcommand
+const sessionRestoreCommand = {
+    name: 'session-restore',
+    description: 'Restore a previous session',
     options: [
         {
-            name: 'command',
-            short: 'c',
-            description: 'Command that was executed',
+            name: 'session-id',
+            short: 'i',
+            description: 'Session ID to restore (use "latest" for most recent)',
             type: 'string',
-            required: true
+            default: 'latest'
         },
         {
-            name: 'success',
-            short: 's',
-            description: 'Whether the command succeeded',
+            name: 'restore-agents',
+            short: 'a',
+            description: 'Restore spawned agents',
             type: 'boolean',
-            required: false
-        },
-        {
-            name: 'exit-code',
-            short: 'e',
-            description: 'Command exit code',
-            type: 'number',
-            default: 0
+            default: true
         },
         {
-            name: 'duration',
-            short: 'd',
-            description: 'Execution duration in milliseconds',
-            type: 'number'
+            name: 'restore-tasks',
+            short: 't',
+            description: 'Restore active tasks',
+            type: 'boolean',
+            default: true
         }
     ],
     examples: [
-        { command: 'monomind hooks post-command -c "npm test" --success true', description: 'Record successful test run' },
-        { command: 'monomind hooks post-command -c "npm build" --success false -e 1', description: 'Record failed build' }
+        { command: 'monomind hooks session-restore', description: 'Restore latest session' },
+        { command: 'monomind hooks session-restore -i session-12345', description: 'Restore specific session' }
     ],
     action: async (ctx) => {
-        const command = ctx.args[0] || ctx.flags.command;
-        // Default success to true for backward compatibility
-        const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
-        if (!command) {
-            output.printError('Command is required. Use --command or -c flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Recording command outcome: ${output.highlight(command)}`);
+        const sessionId = ctx.args[0] || ctx.flags['session-id'] || 'latest';
+        output.printInfo(`Restoring session: ${output.highlight(sessionId)}`);
         try {
-            // Call MCP tool for post-command hook
-            const result = await callMCPTool('hooks_post-command', {
-                command,
-                success,
-                exitCode: ctx.flags['exit-code'] || 0,
-                duration: ctx.flags.duration,
+            const result = await callMCPTool('hooks_session-restore', {
+                sessionId,
+                restoreAgents: ctx.flags['restore-agents'] ?? true,
+                restoreTasks: ctx.flags['restore-tasks'] ?? true,
                 timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
@@ -588,17 +301,31 @@ const postCommandCommand = {
                 return { success: true, data: result };
             }
             output.writeln();
-            output.printSuccess('Command outcome recorded');
-            if (result.learningUpdates) {
+            output.printSuccess(`Session restored from ${result.originalSessionId}`);
+            output.writeln(output.dim(`New session ID: ${result.sessionId}`));
+            output.writeln();
+            output.writeln(output.bold('Restored State'));
+            output.printTable({
+                columns: [
+                    { key: 'item', header: 'Item', width: 25 },
+                    { key: 'count', header: 'Count', width: 15, align: 'right' }
+                ],
+                data: [
+                    { item: 'Tasks', count: result.restoredState.tasksRestored },
+                    { item: 'Agents', count: result.restoredState.agentsRestored },
+                    { item: 'Memory Entries', count: result.restoredState.memoryRestored }
+                ]
+            });
+            if (result.warnings && result.warnings.length > 0) {
                 output.writeln();
-                output.writeln(output.dim(`Patterns updated: ${result.learningUpdates.commandPatternsUpdated}`));
-                output.writeln(output.dim(`Risk assessment: ${result.learningUpdates.riskAssessmentUpdated ? 'Updated' : 'No change'}`));
+                output.writeln(output.bold(output.warning('Warnings')));
+                output.printList(result.warnings.map(w => output.warning(w)));
             }
             return { success: true, data: result };
         }
         catch (error) {
             if (error instanceof MCPClientError) {
-                output.printError(`Post-command hook failed: ${error.message}`);
+                output.printError(`Session-restore hook failed: ${error.message}`);
             }
             else {
                 output.printError(`Unexpected error: ${String(error)}`);
@@ -607,3092 +334,12 @@ const postCommandCommand = {
         }
     }
 };
-// Route subcommand
-const routeCommand = {
-    name: 'route',
-    description: 'Route task to optimal agent using learned patterns',
-    options: [
-        {
-            name: 'task',
-            short: 't',
-            description: 'Task description',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'context',
-            short: 'c',
-            description: 'Additional context',
-            type: 'string'
-        },
-        {
-            name: 'top-k',
-            short: 'K',
-            description: 'Number of top agent suggestions',
-            type: 'number',
-            default: 3
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks route -t "Fix authentication bug"', description: 'Route task to optimal agent' },
-        { command: 'monomind hooks route -t "Optimize database queries" -K 5', description: 'Get top 5 suggestions' }
-    ],
-    action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
-        const topK = ctx.flags['top-k'] || 3;
-        if (!task) {
-            output.printError('Task description is required. Use --task or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Routing task: ${output.highlight(task)}`);
-        try {
-            // Call MCP tool for routing
-            const result = await callMCPTool('hooks_route', {
-                task,
-                context: ctx.flags.context,
-                topK,
-                includeEstimates: true,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            // Show routing method info
-            if (result.routing) {
-                output.writeln();
-                output.writeln(output.bold('Routing Method'));
-                const methodDisplay = result.routing.method.startsWith('semantic')
-                    ? output.success(`${result.routing.method} (${result.routing.backend || 'semantic'})`)
-                    : 'keyword';
-                output.printList([
-                    `Method: ${methodDisplay}`,
-                    result.routing.backend ? `Backend: ${result.routing.backend}` : null,
-                    `Latency: ${result.routing.latencyMs.toFixed(3)}ms`,
-                    result.matchedPattern ? `Matched Pattern: ${result.matchedPattern}` : null,
-                ].filter(Boolean));
-                // Show semantic matches if available
-                if (result.semanticMatches && result.semanticMatches.length > 0) {
-                    output.writeln();
-                    output.writeln(output.dim('Semantic Matches:'));
-                    result.semanticMatches.forEach(m => {
-                        output.writeln(`  ${m.pattern}: ${(m.score * 100).toFixed(1)}%`);
-                    });
-                }
-            }
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.primaryAgent.type)}`,
-                `Confidence: ${(result.primaryAgent.confidence * 100).toFixed(1)}%`,
-                `Reason: ${result.primaryAgent.reason}`
-            ].join('\n'), 'Primary Recommendation');
-            if (result.alternativeAgents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Alternative Agents'));
-                output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Agent Type', width: 20 },
-                        { key: 'confidence', header: 'Confidence', width: 12, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(1)}%` },
-                        { key: 'reason', header: 'Reason', width: 35 }
-                    ],
-                    data: result.alternativeAgents
-                });
-            }
-            if (result.estimatedMetrics) {
-                output.writeln();
-                output.writeln(output.bold('Estimated Metrics'));
-                output.printList([
-                    `Success Probability: ${(result.estimatedMetrics.successProbability * 100).toFixed(1)}%`,
-                    `Estimated Duration: ${result.estimatedMetrics.estimatedDuration}`,
-                    `Complexity: ${result.estimatedMetrics.complexity.toUpperCase()}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Routing failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Explain subcommand
-const explainCommand = {
-    name: 'explain',
-    description: 'Explain routing decision with transparency',
-    options: [
-        {
-            name: 'task',
-            short: 't',
-            description: 'Task description',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'agent',
-            short: 'a',
-            description: 'Agent type to explain',
-            type: 'string'
-        },
-        {
-            name: 'verbose',
-            short: 'v',
-            description: 'Verbose explanation',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks explain -t "Fix authentication bug"', description: 'Explain routing decision' },
-        { command: 'monomind hooks explain -t "Optimize queries" -a coder --verbose', description: 'Verbose explanation for specific agent' }
-    ],
-    action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
-        if (!task) {
-            output.printError('Task description is required. Use --task or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Explaining routing for: ${output.highlight(task)}`);
-        try {
-            // Call MCP tool for explanation
-            const result = await callMCPTool('hooks_explain', {
-                task,
-                agent: ctx.flags.agent,
-                verbose: ctx.flags.verbose || false,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Decision Explanation'));
-            output.writeln();
-            output.writeln(result.explanation);
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.decision.agent)}`,
-                `Confidence: ${(result.decision.confidence * 100).toFixed(1)}%`
-            ].join('\n'), 'Final Decision');
-            if (result.decision.reasoning.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Reasoning Steps'));
-                output.printList(result.decision.reasoning.map((r, i) => `${i + 1}. ${r}`));
-            }
-            if (result.factors.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Decision Factors'));
-                output.printTable({
-                    columns: [
-                        { key: 'factor', header: 'Factor', width: 20 },
-                        { key: 'weight', header: 'Weight', width: 10, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(0)}%` },
-                        { key: 'value', header: 'Value', width: 10, align: 'right', format: (v) => Number(v).toFixed(2) },
-                        { key: 'impact', header: 'Impact', width: 25 }
-                    ],
-                    data: result.factors
-                });
-            }
-            if (result.patterns.length > 0 && ctx.flags.verbose) {
-                output.writeln();
-                output.writeln(output.bold('Matched Patterns'));
-                result.patterns.forEach((p, i) => {
-                    output.writeln();
-                    output.writeln(`${i + 1}. ${output.highlight(p.pattern)} (${(p.matchScore * 100).toFixed(1)}% match)`);
-                    if (p.examples.length > 0) {
-                        output.printList(p.examples.slice(0, 3).map(e => output.dim(`  ${e}`)));
-                    }
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Explanation failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Pretrain subcommand
-const pretrainCommand = {
-    name: 'pretrain',
-    description: 'Bootstrap intelligence from repository (4-step pipeline + embeddings)',
-    options: [
-        {
-            name: 'path',
-            short: 'p',
-            description: 'Repository path',
-            type: 'string',
-            default: '.'
-        },
-        {
-            name: 'depth',
-            short: 'd',
-            description: 'Analysis depth (shallow, medium, deep)',
-            type: 'string',
-            default: 'medium',
-            choices: ['shallow', 'medium', 'deep']
-        },
-        {
-            name: 'skip-cache',
-            description: 'Skip cached analysis',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'with-embeddings',
-            description: 'Index documents for semantic search during pretraining',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'embedding-model',
-            description: 'ONNX embedding model',
-            type: 'string',
-            default: 'Xenova/all-MiniLM-L6-v2',
-            choices: ['Xenova/all-MiniLM-L6-v2', 'Xenova/all-mpnet-base-v2']
-        },
-        {
-            name: 'file-types',
-            description: 'File extensions to index (comma-separated)',
-            type: 'string',
-            default: 'ts,js,py,md,json'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks pretrain', description: 'Pretrain with embeddings indexing' },
-        { command: 'monomind hooks pretrain -p ../my-project --depth deep', description: 'Deep analysis of specific project' },
-        { command: 'monomind hooks pretrain --no-with-embeddings', description: 'Skip embedding indexing' },
-        { command: 'monomind hooks pretrain --file-types ts,tsx,js', description: 'Index only TypeScript/JS files' }
-    ],
-    action: async (ctx) => {
-        const repoPath = ctx.flags.path || '.';
-        const depth = ctx.flags.depth || 'medium';
-        const withEmbeddings = ctx.flags['with-embeddings'] !== false && ctx.flags.withEmbeddings !== false;
-        const embeddingModel = (ctx.flags['embedding-model'] || ctx.flags.embeddingModel || 'Xenova/all-MiniLM-L6-v2');
-        const fileTypes = (ctx.flags['file-types'] || ctx.flags.fileTypes || 'ts,js,py,md,json');
-        output.writeln();
-        output.writeln(output.bold('Pretraining Intelligence (4-Step Pipeline + Embeddings)'));
-        output.writeln();
-        const steps = [
-            { name: 'RETRIEVE', desc: 'Top-k memory injection with MMR diversity' },
-            { name: 'JUDGE', desc: 'LLM-as-judge trajectory evaluation' },
-            { name: 'DISTILL', desc: 'Extract strategy memories from trajectories' },
-            { name: 'CONSOLIDATE', desc: 'Dedup, detect contradictions, prune old patterns' }
-        ];
-        // Add embedding steps if enabled
-        if (withEmbeddings) {
-            steps.push({ name: 'EMBED', desc: `Index documents with ${embeddingModel} (ONNX)` }, { name: 'HYPERBOLIC', desc: 'Project to Poincaré ball for hierarchy preservation' });
-        }
-        const spinner = output.createSpinner({ text: 'Starting pretraining...', spinner: 'dots' });
-        try {
-            spinner.start();
-            // Display progress for each step
-            for (const step of steps) {
-                spinner.setText(`${step.name}: ${step.desc}`);
-                await new Promise(resolve => setTimeout(resolve, 800));
-            }
-            // Call MCP tool for pretraining
-            const result = await callMCPTool('hooks_pretrain', {
-                path: repoPath,
-                depth,
-                skipCache: ctx.flags['skip-cache'] || false,
-                withEmbeddings,
-                embeddingModel,
-                fileTypes: fileTypes.split(',').map((t) => t.trim()),
-            });
-            spinner.succeed('Pretraining completed');
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            // Base stats
-            const tableData = [
-                { metric: 'Files Analyzed', value: result.stats.filesAnalyzed },
-                { metric: 'Patterns Extracted', value: result.stats.patternsExtracted },
-                { metric: 'Strategies Learned', value: result.stats.strategiesLearned },
-                { metric: 'Trajectories Evaluated', value: result.stats.trajectoriesEvaluated },
-                { metric: 'Contradictions Resolved', value: result.stats.contradictionsResolved },
-            ];
-            // Add embedding stats if available
-            if (withEmbeddings && result.stats.documentsIndexed !== undefined) {
-                tableData.push({ metric: 'Documents Indexed', value: result.stats.documentsIndexed }, { metric: 'Embeddings Generated', value: result.stats.embeddingsGenerated || 0 }, { metric: 'Hyperbolic Projections', value: result.stats.hyperbolicProjections || 0 });
-            }
-            tableData.push({ metric: 'Duration', value: `${(result.duration / 1000).toFixed(1)}s` });
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 30 },
-                    { key: 'value', header: 'Value', width: 15, align: 'right' }
-                ],
-                data: tableData
-            });
-            output.writeln();
-            output.printSuccess('Repository intelligence bootstrapped successfully');
-            if (withEmbeddings) {
-                output.writeln(output.dim('  Semantic search enabled: Use "embeddings search -q <query>" to search'));
-            }
-            output.writeln(output.dim('  Next step: Run "monomind hooks build-agents" to generate optimized configs'));
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Pretraining failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Pretraining error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Build agents subcommand
-const buildAgentsCommand = {
-    name: 'build-agents',
-    description: 'Generate optimized agent configs from pretrain data',
-    options: [
-        {
-            name: 'output',
-            short: 'o',
-            description: 'Output directory for agent configs',
-            type: 'string',
-            default: './agents'
-        },
-        {
-            name: 'focus',
-            short: 'f',
-            description: 'Focus area (v1-implementation, security, performance, all)',
-            type: 'string',
-            default: 'all'
-        },
-        {
-            name: 'config-format',
-            description: 'Config format (yaml, json)',
-            type: 'string',
-            default: 'yaml',
-            choices: ['yaml', 'json']
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks build-agents', description: 'Build all agent configs' },
-        { command: 'monomind hooks build-agents --focus security -o ./config/agents', description: 'Build security-focused configs' }
-    ],
-    action: async (ctx) => {
-        const output_dir = ctx.flags.output || './agents';
-        const focus = ctx.flags.focus || 'all';
-        const configFormat = ctx.flags.configFormat || 'yaml';
-        output.printInfo(`Building agent configs (focus: ${output.highlight(focus)})`);
-        const spinner = output.createSpinner({ text: 'Generating configs...', spinner: 'dots' });
-        try {
-            spinner.start();
-            // Call MCP tool for building agents
-            const result = await callMCPTool('hooks_build-agents', {
-                outputDir: output_dir,
-                focus,
-                format: configFormat,
-                includePretrained: true,
-            });
-            spinner.succeed(`Generated ${result.agents.length} agent configs`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Generated Agent Configs'));
-            output.printTable({
-                columns: [
-                    { key: 'type', header: 'Agent Type', width: 20 },
-                    { key: 'configFile', header: 'Config File', width: 30 },
-                    { key: 'capabilities', header: 'Capabilities', width: 10, align: 'right', format: (v) => String(Array.isArray(v) ? v.length : 0) }
-                ],
-                data: result.agents
-            });
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 30 },
-                    { key: 'value', header: 'Value', width: 15, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Configs Generated', value: result.stats.configsGenerated },
-                    { metric: 'Patterns Applied', value: result.stats.patternsApplied },
-                    { metric: 'Optimizations Included', value: result.stats.optimizationsIncluded }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Agent configs saved to ${output_dir}`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Agent config generation failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Build agents error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Metrics subcommand
-const metricsCommand = {
-    name: 'metrics',
-    description: 'View learning metrics dashboard',
-    options: [
-        {
-            name: 'period',
-            short: 'p',
-            description: 'Time period (1h, 24h, 7d, 30d, all)',
-            type: 'string',
-            default: '24h'
-        },
-        {
-            name: 'v1-dashboard',
-            description: 'Show v1 performance dashboard',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'category',
-            short: 'c',
-            description: 'Metric category (patterns, agents, commands, performance)',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks metrics', description: 'View 24h metrics' },
-        { command: 'monomind hooks metrics --period 7d --v1-dashboard', description: 'v1 metrics for 7 days' }
-    ],
-    action: async (ctx) => {
-        const period = ctx.flags.period || '24h';
-        const v1Dashboard = ctx.flags.v1Dashboard;
-        output.writeln();
-        output.writeln(output.bold(`Learning Metrics Dashboard (${period})`));
-        output.writeln();
-        try {
-            // Call MCP tool for metrics
-            const result = await callMCPTool('hooks_metrics', {
-                period,
-                includev1: v1Dashboard,
-                category: ctx.flags.category,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            // Patterns section
-            output.writeln(output.bold('📊 Pattern Learning'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Total Patterns', value: result.patterns.total },
-                    { metric: 'Successful', value: output.success(String(result.patterns.successful)) },
-                    { metric: 'Failed', value: output.error(String(result.patterns.failed)) },
-                    { metric: 'Avg Confidence', value: `${(result.patterns.avgConfidence * 100).toFixed(1)}%` }
-                ]
-            });
-            output.writeln();
-            // Agent routing section
-            output.writeln(output.bold('🤖 Agent Routing'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Routing Accuracy', value: `${(result.agents.routingAccuracy * 100).toFixed(1)}%` },
-                    { metric: 'Total Routes', value: result.agents.totalRoutes },
-                    { metric: 'Top Agent', value: output.highlight(result.agents.topAgent) }
-                ]
-            });
-            output.writeln();
-            // Command execution section
-            output.writeln(output.bold('⚡ Command Execution'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Total Executed', value: result.commands.totalExecuted },
-                    { metric: 'Success Rate', value: `${(result.commands.successRate * 100).toFixed(1)}%` },
-                    { metric: 'Avg Risk Score', value: result.commands.avgRiskScore.toFixed(2) }
-                ]
-            });
-            if (v1Dashboard && result.performance) {
-                const p = result.performance;
-                output.writeln();
-                output.writeln(output.bold('🚀 v1 Performance Gains'));
-                output.printList([
-                    `Memory Reduction: ${output.success(p.memoryReduction ?? 'N/A')}`,
-                    `Search Improvement: ${output.success(p.searchImprovement ?? 'N/A')}`,
-                    `Token Reduction: ${output.success(p.tokenReduction ?? 'N/A')}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Metrics error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Pattern Store command (imported from transfer-store.ts)
-// storeCommand is imported at the top
-// Transfer from project subcommand
-const transferFromProjectCommand = {
-    name: 'from-project',
-    aliases: ['project'],
-    description: 'Transfer patterns from another project',
-    options: [
-        {
-            name: 'source',
-            short: 's',
-            description: 'Source project path',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'filter',
-            short: 'f',
-            description: 'Filter patterns by type',
-            type: 'string'
-        },
-        {
-            name: 'min-confidence',
-            short: 'm',
-            description: 'Minimum confidence threshold (0-1)',
-            type: 'number',
-            default: 0.7
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks transfer from-project -s ../old-project', description: 'Transfer all patterns' },
-        { command: 'monomind hooks transfer from-project -s ../prod --filter security -m 0.9', description: 'Transfer high-confidence security patterns' }
-    ],
-    action: async (ctx) => {
-        const sourcePath = ctx.args[0] || ctx.flags.source;
-        const minConfidence = ctx.flags['min-confidence'] || 0.7;
-        if (!sourcePath) {
-            output.printError('Source project path is required. Use --source or -s flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Transferring patterns from: ${output.highlight(sourcePath)}`);
-        const spinner = output.createSpinner({ text: 'Analyzing source patterns...', spinner: 'dots' });
-        try {
-            spinner.start();
-            // Call MCP tool for transfer
-            const result = await callMCPTool('hooks_transfer', {
-                sourcePath,
-                filter: ctx.flags.filter,
-                minConfidence,
-                mergeStrategy: 'keep-highest-confidence',
-            });
-            spinner.succeed(`Transferred ${result.transferred.total} patterns`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Transfer Summary'));
-            output.printTable({
-                columns: [
-                    { key: 'category', header: 'Category', width: 25 },
-                    { key: 'count', header: 'Count', width: 15, align: 'right' }
-                ],
-                data: [
-                    { category: 'Total Transferred', count: output.success(String(result.transferred.total)) },
-                    { category: 'Skipped (Low Confidence)', count: result.skipped.lowConfidence },
-                    { category: 'Skipped (Duplicates)', count: result.skipped.duplicates },
-                    { category: 'Skipped (Conflicts)', count: result.skipped.conflicts }
-                ]
-            });
-            if (Object.keys(result.transferred.byType).length > 0) {
-                output.writeln();
-                output.writeln(output.bold('By Pattern Type'));
-                output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Type', width: 20 },
-                        { key: 'count', header: 'Count', width: 15, align: 'right' }
-                    ],
-                    data: Object.entries(result.transferred.byType).map(([type, count]) => ({ type, count }))
-                });
-            }
-            output.writeln();
-            output.printList([
-                `Avg Confidence: ${(result.stats.avgConfidence * 100).toFixed(1)}%`,
-                `Avg Age: ${result.stats.avgAge}`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Transfer failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Transfer error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Parent transfer command combining all transfer methods
-const transferCommand = {
-    name: 'transfer',
-    description: 'Transfer patterns and plugins via IPFS-based decentralized registry',
-    subcommands: [storeCommand, transferFromProjectCommand],
-    examples: [
-        { command: 'monomind hooks transfer store list', description: 'List patterns from registry' },
-        { command: 'monomind hooks transfer store search -q routing', description: 'Search patterns' },
-        { command: 'monomind hooks transfer store download -p seraphine-genesis', description: 'Download pattern' },
-        { command: 'monomind hooks transfer store publish', description: 'Publish pattern to registry' },
-        { command: 'monomind hooks transfer from-project -s ../other-project', description: 'Transfer from project' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Pattern Transfer System'));
-        output.writeln(output.dim('Decentralized pattern sharing via IPFS'));
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('store')}        - Pattern marketplace (list, search, download, publish)`,
-            `${output.highlight('from-project')} - Transfer patterns from another project`,
-        ]);
-        output.writeln();
-        output.writeln(output.bold('IPFS-Based Features:'));
-        output.printList([
-            'Decentralized registry via IPNS for discoverability',
-            'Content-addressed storage for integrity',
-            'Ed25519 signatures for verification',
-            'Anonymization levels: minimal, standard, strict, paranoid',
-            'Trust levels: unverified, community, verified, official',
-        ]);
-        output.writeln();
-        output.writeln('Run "monomind hooks transfer <subcommand> --help" for details');
-        return { success: true };
-    }
-};
-// List subcommand
-const listCommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List all registered hooks',
-    options: [
-        {
-            name: 'enabled',
-            short: 'e',
-            description: 'Show only enabled hooks',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'type',
-            short: 't',
-            description: 'Filter by hook type',
-            type: 'string'
-        }
-    ],
-    action: async (ctx) => {
-        try {
-            // Call MCP tool for list
-            const result = await callMCPTool('hooks_list', {
-                enabled: ctx.flags.enabled || undefined,
-                type: ctx.flags.type || undefined,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Registered Hooks'));
-            output.writeln();
-            if (result.hooks.length === 0) {
-                output.printInfo('No hooks found matching criteria');
-                return { success: true, data: result };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'name', header: 'Name', width: 20 },
-                    { key: 'type', header: 'Type', width: 15 },
-                    { key: 'enabled', header: 'Enabled', width: 10, format: (v) => v ? output.success('Yes') : output.dim('No') },
-                    { key: 'priority', header: 'Priority', width: 10, align: 'right' },
-                    { key: 'executionCount', header: 'Executions', width: 12, align: 'right' },
-                    { key: 'lastExecuted', header: 'Last Executed', width: 20, format: (v) => v ? new Date(String(v)).toLocaleString() : 'Never' }
-                ],
-                data: result.hooks
-            });
-            output.writeln();
-            output.printInfo(`Total: ${result.total} hooks`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to list hooks: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Pre-task subcommand
-const preTaskCommand = {
-    name: 'pre-task',
-    description: 'Record task start and get agent suggestions',
-    options: [
-        {
-            name: 'task-id',
-            short: 'i',
-            description: 'Unique task identifier (auto-generated if omitted)',
-            type: 'string'
-        },
-        {
-            name: 'description',
-            short: 'd',
-            description: 'Task description',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'auto-spawn',
-            short: 'a',
-            description: 'Auto-spawn suggested agents',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks pre-task -i task-123 -d "Fix auth bug"', description: 'Record task start' },
-        { command: 'monomind hooks pre-task -i task-456 -d "Implement feature" --auto-spawn', description: 'With auto-spawn' }
-    ],
-    action: async (ctx) => {
-        const taskId = ctx.flags['task-id'] || `task-${Date.now().toString(36)}`;
-        const description = ctx.args[0] || ctx.flags.description;
-        if (!description) {
-            output.printError('Description is required: --description "your task"');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Starting task: ${output.highlight(taskId)}`);
-        try {
-            const result = await callMCPTool('hooks_pre-task', {
-                taskId,
-                description,
-                autoSpawn: ctx.flags['auto-spawn'] || false,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Task ID: ${result.taskId}`,
-                `Description: ${result.description}`,
-                `Complexity: ${result.complexity.toUpperCase()}`,
-                `Est. Duration: ${result.estimatedDuration}`
-            ].join('\n'), 'Task Registered');
-            if (result.suggestedAgents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Suggested Agents'));
-                output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Agent Type', width: 20 },
-                        { key: 'confidence', header: 'Confidence', width: 12, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(1)}%` },
-                        { key: 'reason', header: 'Reason', width: 35 }
-                    ],
-                    data: result.suggestedAgents
-                });
-            }
-            if (result.risks.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(output.error('Potential Risks')));
-                output.printList(result.risks.map(r => output.warning(r)));
-            }
-            if (result.recommendations.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Recommendations'));
-                output.printList(result.recommendations);
-            }
-            // Monograph graph-first reminder — always surface before the agent starts grepping
-            if (description) {
-                output.writeln();
-                output.writeln(output.bold('[MONOGRAPH] Graph-first protocol:'));
-                output.printList([
-                    `mcp__monomind__monograph_suggest task="${description.slice(0, 80)}" — get relevant nodes ranked by task`,
-                    'mcp__monomind__monograph_query   — BM25 lookup before any grep/find via Bash',
-                    'mcp__monomind__monograph_impact  — blast radius before editing shared code',
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Pre-task hook failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Post-task subcommand
-const postTaskCommand = {
-    name: 'post-task',
-    description: 'Record task completion for learning',
-    options: [
-        {
-            name: 'task-id',
-            short: 'i',
-            description: 'Unique task identifier (auto-generated if not provided)',
-            type: 'string',
-            required: false
-        },
-        {
-            name: 'success',
-            short: 's',
-            description: 'Whether the task succeeded',
-            type: 'boolean',
-            required: false
-        },
-        {
-            name: 'quality',
-            short: 'q',
-            description: 'Quality score (0-1)',
-            type: 'number'
-        },
-        {
-            name: 'agent',
-            short: 'a',
-            description: 'Agent that executed the task',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks post-task -i task-123 --success true', description: 'Record successful completion' },
-        { command: 'monomind hooks post-task -i task-456 --success false -q 0.3', description: 'Record failed task' }
-    ],
-    action: async (ctx) => {
-        // Auto-generate task ID if not provided
-        const taskId = ctx.flags['task-id'] || `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        // Default success to true for backward compatibility
-        const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
-        output.printInfo(`Recording outcome for task: ${output.highlight(taskId)}`);
-        try {
-            const result = await callMCPTool('hooks_post-task', {
-                taskId,
-                success,
-                quality: ctx.flags.quality,
-                agent: ctx.flags.agent,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Task outcome recorded: ${success ? 'SUCCESS' : 'FAILED'}`);
-            output.writeln();
-            output.writeln(output.bold('Learning Updates'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Patterns Updated', value: result.learningUpdates.patternsUpdated },
-                    { metric: 'New Patterns', value: result.learningUpdates.newPatterns },
-                    { metric: 'Duration', value: `${(result.duration / 1000).toFixed(1)}s` },
-                    { metric: 'Trajectory ID', value: result.learningUpdates.trajectoryId }
-                ]
-            });
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Post-task hook failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Session-end subcommand
-const sessionEndCommand = {
-    name: 'session-end',
-    description: 'End current session and persist state',
-    options: [
-        {
-            name: 'save-state',
-            short: 's',
-            description: 'Save session state for later restoration',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks session-end', description: 'End and save session' },
-        { command: 'monomind hooks session-end --save-state false', description: 'End without saving' }
-    ],
-    action: async (ctx) => {
-        output.printInfo('Ending session...');
-        try {
-            const result = await callMCPTool('hooks_session-end', {
-                saveState: ctx.flags['save-state'] ?? true,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Session ${result.sessionId} ended`);
-            output.writeln();
-            output.writeln(output.bold('Session Summary'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 15, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Duration', value: `${(result.duration / 1000 / 60).toFixed(1)} min` },
-                    { metric: 'Tasks Executed', value: result.summary.tasksExecuted },
-                    { metric: 'Tasks Succeeded', value: output.success(String(result.summary.tasksSucceeded)) },
-                    { metric: 'Tasks Failed', value: output.error(String(result.summary.tasksFailed)) },
-                    { metric: 'Commands Executed', value: result.summary.commandsExecuted },
-                    { metric: 'Files Modified', value: result.summary.filesModified },
-                    { metric: 'Agents Spawned', value: result.summary.agentsSpawned }
-                ]
-            });
-            if (result.statePath) {
-                output.writeln();
-                output.writeln(output.dim(`State saved to: ${result.statePath}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Session-end hook failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Session-restore subcommand
-const sessionRestoreCommand = {
-    name: 'session-restore',
-    description: 'Restore a previous session',
-    options: [
-        {
-            name: 'session-id',
-            short: 'i',
-            description: 'Session ID to restore (use "latest" for most recent)',
-            type: 'string',
-            default: 'latest'
-        },
-        {
-            name: 'restore-agents',
-            short: 'a',
-            description: 'Restore spawned agents',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'restore-tasks',
-            short: 't',
-            description: 'Restore active tasks',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks session-restore', description: 'Restore latest session' },
-        { command: 'monomind hooks session-restore -i session-12345', description: 'Restore specific session' }
-    ],
-    action: async (ctx) => {
-        const sessionId = ctx.args[0] || ctx.flags['session-id'] || 'latest';
-        output.printInfo(`Restoring session: ${output.highlight(sessionId)}`);
-        try {
-            const result = await callMCPTool('hooks_session-restore', {
-                sessionId,
-                restoreAgents: ctx.flags['restore-agents'] ?? true,
-                restoreTasks: ctx.flags['restore-tasks'] ?? true,
-                timestamp: Date.now(),
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printSuccess(`Session restored from ${result.originalSessionId}`);
-            output.writeln(output.dim(`New session ID: ${result.sessionId}`));
-            output.writeln();
-            output.writeln(output.bold('Restored State'));
-            output.printTable({
-                columns: [
-                    { key: 'item', header: 'Item', width: 25 },
-                    { key: 'count', header: 'Count', width: 15, align: 'right' }
-                ],
-                data: [
-                    { item: 'Tasks', count: result.restoredState.tasksRestored },
-                    { item: 'Agents', count: result.restoredState.agentsRestored },
-                    { item: 'Memory Entries', count: result.restoredState.memoryRestored }
-                ]
-            });
-            if (result.warnings && result.warnings.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(output.warning('Warnings')));
-                output.printList(result.warnings.map(w => output.warning(w)));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Session-restore hook failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Intelligence subcommand (JS pattern/trajectory logging)
-const intelligenceCommand = {
-    name: 'intelligence',
-    description: 'JS pattern/trajectory logging (stats, pattern-*, trajectory-*)',
-    options: [
-        {
-            name: 'mode',
-            short: 'm',
-            description: 'Intelligence mode (real-time, batch, edge, research, balanced)',
-            type: 'string',
-            choices: ['real-time', 'batch', 'edge', 'research', 'balanced'],
-            default: 'balanced'
-        },
-        {
-            name: 'enable-sona',
-            description: 'Enable SONA sub-0.05ms learning',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'enable-moe',
-            description: 'Enable Mixture of Experts routing',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'enable-hnsw',
-            description: 'Enable HNSW 150x faster search',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'status',
-            short: 's',
-            description: 'Show current intelligence status',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'train',
-            short: 't',
-            description: 'Force training cycle',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'reset',
-            short: 'r',
-            description: 'Reset learning state',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'embedding-provider',
-            description: 'Embedding provider (transformers, openai, mock)',
-            type: 'string',
-            choices: ['transformers', 'openai', 'mock'],
-            default: 'transformers'
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks intelligence --status', description: 'Show intelligence status' },
-        { command: 'monomind hooks intelligence -m real-time', description: 'Enable real-time mode' },
-        { command: 'monomind hooks intelligence --train', description: 'Force training cycle' }
-    ],
-    action: async (ctx) => {
-        const mode = ctx.flags.mode || 'balanced';
-        const showStatus = ctx.flags.status;
-        const forceTraining = ctx.flags.train;
-        const reset = ctx.flags.reset;
-        const enableSona = ctx.flags['enable-sona'] ?? true;
-        const enableMoe = ctx.flags['enable-moe'] ?? true;
-        const enableHnsw = ctx.flags['enable-hnsw'] ?? true;
-        const embeddingProvider = ctx.flags['embedding-provider'] || 'transformers';
-        output.writeln();
-        output.writeln(output.bold('Intelligence System'));
-        output.writeln();
-        if (reset) {
-            const confirmed = await confirm({
-                message: 'Reset all learning state? This cannot be undone.',
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Reset cancelled');
-                return { success: true };
-            }
-            output.printInfo('Resetting learning state...');
-            try {
-                await callMCPTool('hooks_intelligence-reset', {});
-                output.printSuccess('Learning state reset');
-                return { success: true };
-            }
-            catch (error) {
-                output.printError(`Reset failed: ${error}`);
-                return { success: false, exitCode: 1 };
-            }
-        }
-        const spinner = output.createSpinner({ text: 'Initializing intelligence system...', spinner: 'dots' });
-        try {
-            spinner.start();
-            // Read local intelligence data from disk first
-            const { getIntelligenceStats, initializeIntelligence, getPersistenceStatus } = await import('../memory/intelligence.js');
-            await initializeIntelligence();
-            const localStats = getIntelligenceStats();
-            const persistence = getPersistenceStatus();
-            // Read patterns.json file size and entry count
-            let patternsFileSize = 0;
-            let patternsFileEntries = 0;
-            if (persistence.patternsExist) {
-                try {
-                    const pStat = statSync(persistence.patternsFile);
-                    patternsFileSize = pStat.size;
-                    if (patternsFileSize <= 4_194_304) {
-                        const pData = JSON.parse(readFileSync(persistence.patternsFile, 'utf-8'));
-                        if (Array.isArray(pData))
-                            patternsFileEntries = pData.length;
-                    }
-                }
-                catch { /* ignore */ }
-            }
-            // Read stats.json for trajectory data
-            let trajectoriesFromDisk = 0;
-            let lastAdaptationFromDisk = null;
-            if (persistence.statsExist) {
-                try {
-                    const sStat = statSync(persistence.statsFile);
-                    if (sStat.size <= 524_288) {
-                        const sData = JSON.parse(readFileSync(persistence.statsFile, 'utf-8'));
-                        trajectoriesFromDisk = sData?.trajectoriesRecorded ?? 0;
-                        lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
-                    }
-                }
-                catch { /* ignore */ }
-            }
-            // Merge local stats with any we can get from MCP
-            let mcpResult = null;
-            try {
-                mcpResult = await callMCPTool('hooks_intelligence', {
-                    mode,
-                    enableSona,
-                    enableMoe,
-                    enableHnsw,
-                    embeddingProvider,
-                    forceTraining,
-                    showStatus,
-                });
-            }
-            catch {
-                // MCP not available, use local data only
-            }
-            // Build merged result, preferring local real data over MCP zeros
-            const hasLocalData = localStats.patternsLearned > 0 || trajectoriesFromDisk > 0 || patternsFileEntries > 0;
-            // Use the higher of local vs MCP values for key stats
-            const mcpComponents = mcpResult?.components;
-            const mcpSona = mcpComponents?.sona;
-            const mcpMoe = mcpComponents?.moe;
-            const mcpHnsw = mcpComponents?.hnsw;
-            const mcpEmb = mcpComponents?.embeddings;
-            const mcpPerf = mcpResult?.performance;
-            const patternsLearned = Math.max(localStats.patternsLearned, patternsFileEntries, Number(mcpSona?.patternsLearned ?? 0));
-            const trajectories = Math.max(localStats.trajectoriesRecorded, trajectoriesFromDisk, Number(mcpSona?.trajectoriesRecorded ?? 0));
-            const lastAdaptation = lastAdaptationFromDisk ?? localStats.lastAdaptation;
-            const avgAdaptation = localStats.avgAdaptationTime > 0 ? localStats.avgAdaptationTime : Number(mcpSona?.adaptationTimeMs ?? 0);
-            const result = {
-                mode: String(mcpResult?.mode ?? mode),
-                status: (hasLocalData || mcpResult) ? 'active' : 'idle',
-                components: {
-                    sona: {
-                        enabled: enableSona,
-                        status: localStats.sonaEnabled ? 'active' : String(mcpSona?.status ?? 'idle'),
-                        learningTimeMs: avgAdaptation,
-                        adaptationTimeMs: avgAdaptation,
-                        trajectoriesRecorded: trajectories,
-                        patternsLearned,
-                        avgQuality: Number(mcpSona?.avgQuality ?? (patternsLearned > 0 ? 0.75 : 0)),
-                    },
-                    moe: {
-                        enabled: enableMoe,
-                        status: String(mcpMoe?.status ?? (hasLocalData ? 'active' : 'idle')),
-                        expertsActive: Number(mcpMoe?.expertsActive ?? (hasLocalData ? 8 : 0)),
-                        routingAccuracy: Number(mcpMoe?.routingAccuracy ?? (hasLocalData ? 0.82 : 0)),
-                        loadBalance: Number(mcpMoe?.loadBalance ?? (hasLocalData ? 0.9 : 0)),
-                    },
-                    hnsw: {
-                        enabled: enableHnsw,
-                        status: String(mcpHnsw?.status ?? (localStats.reasoningBankSize > 0 ? 'active' : 'idle')),
-                        indexSize: Math.max(localStats.reasoningBankSize, Number(mcpHnsw?.indexSize ?? 0)),
-                        searchSpeedup: String(mcpHnsw?.searchSpeedup ?? (localStats.reasoningBankSize > 0 ? 'pure-JS HNSW' : 'N/A')),
-                        memoryUsage: String(mcpHnsw?.memoryUsage ?? (patternsFileSize > 0 ? `${(patternsFileSize / 1024).toFixed(1)} KB` : 'N/A')),
-                        dimension: Number(mcpHnsw?.dimension ?? 384),
-                    },
-                    embeddings: mcpEmb ? {
-                        provider: String(mcpEmb.provider ?? embeddingProvider),
-                        model: String(mcpEmb.model ?? 'default'),
-                        dimension: Number(mcpEmb.dimension ?? 384),
-                        cacheHitRate: Number(mcpEmb.cacheHitRate ?? 0),
-                    } : {
-                        provider: embeddingProvider,
-                        model: 'hash-128',
-                        dimension: 128,
-                        cacheHitRate: 0,
-                    },
-                },
-                performance: mcpPerf ?? {
-                    memoryReduction: patternsFileSize > 0 ? `${(patternsFileSize / 1024).toFixed(1)} KB on disk` : 'N/A',
-                    searchImprovement: localStats.reasoningBankSize > 0 ? 'pure-JS HNSW' : 'N/A',
-                    tokenReduction: 'N/A',
-                    sweBenchScore: 'N/A',
-                },
-                lastTrainingMs: lastAdaptation ? Date.now() - lastAdaptation : undefined,
-                persistence: {
-                    dataDir: persistence.dataDir,
-                    patternsFile: persistence.patternsFile,
-                    patternsExist: persistence.patternsExist,
-                    patternsEntries: patternsFileEntries,
-                    patternsFileSize,
-                    statsFile: persistence.statsFile,
-                    statsExist: persistence.statsExist,
-                    trajectoriesFromDisk,
-                },
-            };
-            if (forceTraining) {
-                spinner.setText('Running training cycle...');
-                const { recordTrajectory, recordStep, flushPatterns, getIntelligenceStats: getStats, } = await import('../memory/intelligence.js');
-                // Record a real trajectory step and then end it with a 'success' verdict
-                // so endTrajectory → distillLearning runs the full EWC+LoRA pipeline.
-                const content = localStats.patternsLearned > 0
-                    ? `training cycle: ${localStats.patternsLearned} patterns, ${localStats.trajectoriesRecorded} trajectories`
-                    : 'bootstrap training: initializing intelligence system';
-                await recordStep({ type: 'action', content });
-                await recordTrajectory([{ type: 'action', content }], 'success');
-                flushPatterns();
-                const updatedStats = getStats();
-                spinner.succeed(`Training cycle complete — ${updatedStats.patternsLearned} patterns, EWC+LoRA applied`);
-                return {
-                    success: true,
-                    data: { patternsLearned: updatedStats.patternsLearned, trajectoriesRecorded: updatedStats.trajectoriesRecorded },
-                };
-            }
-            else {
-                spinner.succeed(hasLocalData ? 'Intelligence system active (local data loaded)' : 'Intelligence system active');
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            // Status display
-            output.writeln();
-            output.printBox([
-                `Mode: ${output.highlight(result.mode)}`,
-                `Status: ${formatIntelligenceStatus(result.status)}`,
-                `Last Training: ${result.lastTrainingMs != null ? `${(result.lastTrainingMs / 1000).toFixed(0)}s ago` : 'Never'}`,
-                `Data Dir: ${output.dim(persistence.dataDir)}`
-            ].join('\n'), 'Intelligence Status');
-            // SONA Component
-            output.writeln();
-            output.writeln(output.bold('SONA (Sub-0.05ms Learning)'));
-            const sona = result.components.sona;
-            if (sona.enabled) {
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(sona.status) },
-                        { metric: 'Learning Time', value: `${(sona.learningTimeMs ?? 0).toFixed(3)}ms` },
-                        { metric: 'Adaptation Time', value: `${(sona.adaptationTimeMs ?? 0).toFixed(3)}ms` },
-                        { metric: 'Trajectories', value: sona.trajectoriesRecorded ?? 0 },
-                        { metric: 'Patterns Learned', value: sona.patternsLearned ?? 0 },
-                        { metric: 'Avg Quality', value: `${((sona.avgQuality ?? 0) * 100).toFixed(1)}%` }
-                    ]
-                });
-            }
-            else {
-                output.writeln(output.dim('  Disabled'));
-            }
-            // MoE Component
-            output.writeln();
-            output.writeln(output.bold('Mixture of Experts (MoE)'));
-            const moe = result.components.moe;
-            if (moe.enabled) {
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(moe.status) },
-                        { metric: 'Active Experts', value: moe.expertsActive ?? 0 },
-                        { metric: 'Routing Accuracy', value: `${((moe.routingAccuracy ?? 0) * 100).toFixed(1)}%` },
-                        { metric: 'Load Balance', value: `${((moe.loadBalance ?? 0) * 100).toFixed(1)}%` }
-                    ]
-                });
-            }
-            else {
-                output.writeln(output.dim('  Disabled'));
-            }
-            // HNSW Component
-            output.writeln();
-            output.writeln(output.bold('HNSW (Pure-JS Vector Search)'));
-            const hnsw = result.components.hnsw;
-            if (hnsw.enabled) {
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Status', value: formatIntelligenceStatus(hnsw.status) },
-                        { metric: 'Index Size', value: (hnsw.indexSize ?? 0).toLocaleString() },
-                        { metric: 'Search Speedup', value: output.success(hnsw.searchSpeedup ?? 'N/A') },
-                        { metric: 'Memory Usage', value: hnsw.memoryUsage ?? 'N/A' },
-                        { metric: 'Dimension', value: hnsw.dimension ?? 384 }
-                    ]
-                });
-            }
-            else {
-                output.writeln(output.dim('  Disabled'));
-            }
-            // Embeddings
-            output.writeln();
-            output.writeln(output.bold('Embeddings'));
-            const emb = result.components.embeddings;
-            if (emb) {
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Provider', value: emb.provider ?? 'N/A' },
-                        { metric: 'Model', value: emb.model ?? 'N/A' },
-                        { metric: 'Dimension', value: emb.dimension ?? 384 },
-                        { metric: 'Cache Hit Rate', value: `${((emb.cacheHitRate ?? 0) * 100).toFixed(1)}%` }
-                    ]
-                });
-            }
-            else {
-                output.writeln(output.dim('  Not initialized'));
-            }
-            // Persistence info
-            if (result.persistence) {
-                output.writeln();
-                output.writeln(output.bold('Neural Persistence'));
-                output.printList([
-                    `Patterns file: ${persistence.patternsExist ? output.success(`${patternsFileEntries} entries (${(patternsFileSize / 1024).toFixed(1)} KB)`) : output.dim('Not created')}`,
-                    `Stats file: ${persistence.statsExist ? output.success(`${trajectoriesFromDisk} trajectories`) : output.dim('Not created')}`,
-                ]);
-                if (!persistence.patternsExist && !persistence.statsExist) {
-                    output.writeln();
-                    output.writeln(output.dim('  No pattern data yet. Patterns accrue as hooks run.'));
-                }
-            }
-            // Performance
-            const perf = result.performance;
-            if (perf) {
-                output.writeln();
-                output.writeln(output.bold('v1 Performance Gains'));
-                output.printList([
-                    `Memory Reduction: ${output.success(String(perf.memoryReduction ?? 'N/A'))}`,
-                    `Search Improvement: ${output.success(String(perf.searchImprovement ?? 'N/A'))}`,
-                    `Token Reduction: ${output.success(String(perf.tokenReduction ?? 'N/A'))}`,
-                    `SWE-Bench Score: ${output.success(String(perf.sweBenchScore ?? 'N/A'))}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Intelligence system error');
-            if (error instanceof MCPClientError) {
-                output.printError(`Intelligence error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-function formatIntelligenceStatus(status) {
-    switch (status) {
-        case 'active':
-        case 'ready':
-            return output.success(status);
-        case 'training':
-            return output.highlight(status);
-        case 'idle':
-            return output.dim(status);
-        case 'disabled':
-        case 'error':
-            return output.error(status);
-        default:
-            return status;
-    }
-}
-// =============================================================================
-// Worker Commands (12 Background Workers)
-// =============================================================================
-const workerListCommand = {
-    name: 'list',
-    description: 'List all 12 background workers with capabilities',
-    options: [
-        { name: 'status', short: 's', type: 'string', description: 'Filter by status (all, running, completed, pending)' },
-        { name: 'active', short: 'a', type: 'boolean', description: 'Show active worker instances' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker list', description: 'List all workers' },
-        { command: 'monomind hooks worker list --active', description: 'Show active instances' },
-    ],
-    action: async (ctx) => {
-        const spinner = output.createSpinner({ text: 'Loading workers...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-list', {
-                status: ctx.flags['status'] || 'all',
-                includeActive: ctx.flags['active'] !== false,
-            });
-            spinner.succeed('Workers loaded');
-            output.writeln();
-            output.writeln(output.bold('Background Workers (12 Total)'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'trigger', header: 'Worker', width: 14 },
-                    { key: 'priority', header: 'Priority', width: 10 },
-                    { key: 'estimatedDuration', header: 'Est. Time', width: 10 },
-                    { key: 'description', header: 'Description', width: 40 },
-                ],
-                data: result.workers.map(w => ({
-                    trigger: output.highlight(w.trigger),
-                    priority: w.priority === 'critical' ? output.error(w.priority) :
-                        w.priority === 'high' ? output.warning(w.priority) :
-                            w.priority,
-                    estimatedDuration: w.estimatedDuration,
-                    description: w.description,
-                })),
-            });
-            if (ctx.flags['active'] && result.active.count > 0) {
-                output.writeln();
-                output.writeln(output.bold('Active Instances'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Worker ID', width: 35 },
-                        { key: 'trigger', header: 'Type', width: 12 },
-                        { key: 'status', header: 'Status', width: 12 },
-                        { key: 'progress', header: 'Progress', width: 10 },
-                    ],
-                    data: result.active.instances.map(w => ({
-                        id: w.id,
-                        trigger: w.trigger,
-                        status: w.status === 'running' ? output.highlight(w.status) :
-                            w.status === 'completed' ? output.success(w.status) :
-                                w.status === 'failed' ? output.error(w.status) : w.status,
-                        progress: `${w.progress}%`,
-                    })),
-                });
-            }
-            output.writeln();
-            output.writeln(output.dim('Performance targets:'));
-            output.writeln(output.dim(`  Trigger detection: ${result.performanceTargets.triggerDetection}`));
-            output.writeln(output.dim(`  Worker spawn: ${result.performanceTargets.workerSpawn}`));
-            output.writeln(output.dim(`  Max concurrent: ${result.performanceTargets.maxConcurrent}`));
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Failed to load workers');
-            if (error instanceof MCPClientError) {
-                output.printError(`Worker error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerDispatchCommand = {
-    name: 'dispatch',
-    description: 'Dispatch a background worker for analysis/optimization',
-    options: [
-        { name: 'trigger', short: 't', type: 'string', description: 'Worker type (ultralearn, optimize, audit, map, etc.)', required: true },
-        { name: 'context', short: 'c', type: 'string', description: 'Context for the worker (file path, topic)' },
-        { name: 'priority', short: 'p', type: 'string', description: 'Priority (low, normal, high, critical)' },
-        { name: 'sync', short: 's', type: 'boolean', description: 'Wait for completion (synchronous)' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker dispatch -t optimize -c src/', description: 'Dispatch optimize worker' },
-        { command: 'monomind hooks worker dispatch -t audit -p critical', description: 'Security audit with critical priority' },
-        { command: 'monomind hooks worker dispatch -t testgaps --sync', description: 'Test coverage analysis (sync)' },
-    ],
-    action: async (ctx) => {
-        const trigger = ctx.flags['trigger'];
-        const context = ctx.flags['context'] || 'default';
-        const priority = ctx.flags['priority'];
-        const background = !ctx.flags['sync'];
-        if (!trigger) {
-            output.printError('--trigger is required');
-            output.writeln('Available triggers: ultralearn, optimize, consolidate, predict, audit, map, preload, deepdive, document, refactor, benchmark, testgaps');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Dispatching ${trigger} worker...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-dispatch', {
-                trigger,
-                context,
-                priority,
-                background,
-            });
-            if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed(`Worker dispatched: ${result.workerId}`);
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'field', header: 'Field', width: 18 },
-                    { key: 'value', header: 'Value', width: 50 },
-                ],
-                data: [
-                    { field: 'Worker ID', value: output.highlight(result.workerId) },
-                    { field: 'Trigger', value: result.trigger },
-                    { field: 'Context', value: result.context },
-                    { field: 'Priority', value: result.priority },
-                    { field: 'Description', value: result.config.description },
-                    { field: 'Est. Duration', value: result.config.estimatedDuration },
-                    { field: 'Capabilities', value: result.config.capabilities.join(', ') },
-                    { field: 'Status', value: result.status === 'dispatched' ? output.highlight('dispatched (background)') : output.success('completed') },
-                ],
-            });
-            if (background) {
-                output.writeln();
-                output.writeln(output.dim(`Check status: monomind hooks worker status --id ${result.workerId}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Worker dispatch failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Dispatch error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerStatusCommand = {
-    name: 'status',
-    description: 'Get status of workers',
-    options: [
-        { name: 'id', type: 'string', description: 'Specific worker ID to check' },
-        { name: 'all', short: 'a', type: 'boolean', description: 'Include completed workers' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker status', description: 'Show running workers' },
-        { command: 'monomind hooks worker status --id worker_audit_1', description: 'Check specific worker' },
-        { command: 'monomind hooks worker status --all', description: 'Include completed workers' },
-    ],
-    action: async (ctx) => {
-        const workerId = ctx.flags['id'];
-        const includeCompleted = ctx.flags['all'];
-        const spinner = output.createSpinner({ text: 'Checking worker status...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-status', {
-                workerId,
-                includeCompleted,
-            });
-            if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Status retrieved');
-            if (result.worker) {
-                output.writeln();
-                output.writeln(output.bold(`Worker: ${result.worker.id}`));
-                output.printTable({
-                    columns: [
-                        { key: 'field', header: 'Field', width: 15 },
-                        { key: 'value', header: 'Value', width: 40 },
-                    ],
-                    data: [
-                        { field: 'Trigger', value: result.worker.trigger },
-                        { field: 'Context', value: result.worker.context },
-                        { field: 'Status', value: formatWorkerStatus(result.worker.status) },
-                        { field: 'Progress', value: `${result.worker.progress}%` },
-                        { field: 'Phase', value: result.worker.phase },
-                        { field: 'Duration', value: `${result.worker.duration}ms` },
-                    ],
-                });
-            }
-            else if (result.workers && result.workers.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Active Workers'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Worker ID', width: 35 },
-                        { key: 'trigger', header: 'Type', width: 12 },
-                        { key: 'status', header: 'Status', width: 12 },
-                        { key: 'progress', header: 'Progress', width: 10 },
-                        { key: 'duration', header: 'Duration', width: 12 },
-                    ],
-                    data: result.workers.map(w => ({
-                        id: w.id,
-                        trigger: w.trigger,
-                        status: formatWorkerStatus(w.status),
-                        progress: `${w.progress}%`,
-                        duration: `${w.duration}ms`,
-                    })),
-                });
-                if (result.summary) {
-                    output.writeln();
-                    output.writeln(`Total: ${result.summary.total} | Running: ${output.highlight(String(result.summary.running))} | Completed: ${output.success(String(result.summary.completed))} | Failed: ${output.error(String(result.summary.failed))}`);
-                }
-            }
-            else {
-                output.writeln();
-                output.writeln(output.dim('No active workers'));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Status check failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Status error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerDetectCommand = {
-    name: 'detect',
-    description: 'Detect worker triggers from prompt text',
-    options: [
-        { name: 'prompt', short: 'p', type: 'string', description: 'Prompt text to analyze', required: true },
-        { name: 'auto-dispatch', short: 'a', type: 'boolean', description: 'Automatically dispatch detected workers' },
-        { name: 'min-confidence', short: 'm', type: 'string', description: 'Minimum confidence threshold (0-1)' },
-    ],
-    examples: [
-        { command: 'monomind hooks worker detect -p "optimize performance"', description: 'Detect triggers in prompt' },
-        { command: 'monomind hooks worker detect -p "security audit" --auto-dispatch', description: 'Detect and dispatch' },
-    ],
-    action: async (ctx) => {
-        const prompt = ctx.flags['prompt'];
-        const autoDispatch = ctx.flags['auto-dispatch'];
-        const minConfidence = parseFloat(ctx.flags['min-confidence'] || '0.5');
-        if (!prompt) {
-            output.printError('--prompt is required');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Analyzing prompt...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-detect', {
-                prompt,
-                autoDispatch,
-                minConfidence,
-            });
-            if (result.detection.detected) {
-                spinner.succeed(`Detected ${result.triggersFound} worker trigger(s)`);
-            }
-            else {
-                spinner.succeed('No worker triggers detected');
-            }
-            output.writeln();
-            output.writeln(output.bold('Detection Results'));
-            output.writeln(`Prompt: ${output.dim(result.prompt)}`);
-            output.writeln(`Confidence: ${(result.detection.confidence * 100).toFixed(0)}%`);
-            if (result.triggerDetails && result.triggerDetails.length > 0) {
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'trigger', header: 'Trigger', width: 14 },
-                        { key: 'priority', header: 'Priority', width: 10 },
-                        { key: 'description', header: 'Description', width: 45 },
-                    ],
-                    data: result.triggerDetails.map(t => ({
-                        trigger: output.highlight(t.trigger),
-                        priority: t.priority,
-                        description: t.description,
-                    })),
-                });
-            }
-            if (result.autoDispatched && result.workerIds) {
-                output.writeln();
-                output.writeln(output.success('Workers auto-dispatched:'));
-                result.workerIds.forEach(id => {
-                    output.writeln(`  - ${id}`);
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Detection failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Detection error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-const workerCancelCommand = {
-    name: 'cancel',
-    description: 'Cancel a running worker',
-    options: [
-        { name: 'id', type: 'string', description: 'Worker ID to cancel', required: true },
-    ],
-    examples: [
-        { command: 'monomind hooks worker cancel --id worker_audit_1', description: 'Cancel specific worker' },
-    ],
-    action: async (ctx) => {
-        const workerId = ctx.flags['id'];
-        if (!workerId) {
-            output.printError('--id is required');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Cancelling worker ${workerId}...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('hooks_worker-cancel', { workerId });
-            if (!result.success) {
-                spinner.fail(`Failed: ${result.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed(`Worker ${workerId} cancelled`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Cancel failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Cancel error: ${error.message}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-function formatWorkerStatus(status) {
-    switch (status) {
-        case 'running':
-            return output.highlight(status);
-        case 'completed':
-            return output.success(status);
-        case 'failed':
-            return output.error(status);
-        case 'pending':
-            return output.dim(status);
-        default:
-            return status;
-    }
-}
-// ============================================================================
-// Coverage-Aware Routing Commands
-// ============================================================================
-// Coverage route subcommand
-const coverageRouteCommand = {
-    name: 'coverage-route',
-    description: 'Route task to agents based on test coverage gaps (monovector integration)',
-    options: [
-        {
-            name: 'task',
-            short: 't',
-            description: 'Task description to route',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'threshold',
-            description: 'Coverage threshold percentage (default: 80)',
-            type: 'number',
-            default: 80
-        },
-        {
-            name: 'no-monovector',
-            description: 'Disable monovector integration',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks coverage-route -t "fix bug in auth"', description: 'Route with coverage awareness' },
-        { command: 'monomind hooks coverage-route -t "add tests" --threshold 90', description: 'Route with custom threshold' }
-    ],
-    action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
-        const threshold = ctx.flags.threshold || 80;
-        const useMonovector = !ctx.flags['no-monovector'];
-        if (!task) {
-            output.printError('Task description is required. Use --task or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Analyzing coverage and routing task...' });
-        spinner.start();
-        // Try reading coverage from disk first
-        const diskCoverage = readCoverageFromDisk();
-        if (diskCoverage.found) {
-            spinner.succeed(`Coverage data loaded from ${diskCoverage.source}`);
-            // Find files with lowest coverage that may relate to the task
-            const taskLower = task.toLowerCase();
-            const taskWords = taskLower.split(/\s+/).filter(w => w.length > 2);
-            // Score each file by relevance to the task and how low its coverage is
-            const scoredFiles = diskCoverage.entries
-                .filter(e => e.lines < threshold)
-                .map(e => {
-                const fileNameLower = e.filePath.toLowerCase();
-                let relevance = 0;
-                for (const word of taskWords) {
-                    if (fileNameLower.includes(word))
-                        relevance += 2;
-                }
-                // Penalize high coverage (we care about low coverage)
-                const coveragePenalty = e.lines / 100;
-                return { ...e, relevance, score: relevance + (1 - coveragePenalty) };
-            })
-                .sort((a, b) => b.score - a.score);
-            const gaps = scoredFiles.slice(0, 8).map(e => {
-                const { gapType, priority } = classifyCoverageGap(e.lines, threshold);
-                return {
-                    filePath: e.filePath,
-                    coveragePercent: e.lines,
-                    gapType,
-                    priority,
-                    suggestedAgents: suggestAgentsForFile(e.filePath),
-                    reason: `${e.lines.toFixed(1)}% coverage, below ${threshold}%`,
-                };
-            });
-            const criticalGaps = gaps.filter(g => g.gapType === 'critical').length;
-            const primaryAgent = taskLower.includes('test') ? 'tester' :
-                taskLower.includes('security') || taskLower.includes('auth') ? 'security-auditor' :
-                    taskLower.includes('fix') || taskLower.includes('bug') ? 'coder' : 'tester';
-            const suggestions = [];
-            if (criticalGaps > 0)
-                suggestions.push(`${criticalGaps} critical coverage gaps need immediate attention`);
-            if (diskCoverage.summary.overallLineCoverage < threshold) {
-                suggestions.push(`Overall line coverage (${diskCoverage.summary.overallLineCoverage.toFixed(1)}%) is below ${threshold}% threshold`);
-            }
-            if (scoredFiles.length > 8)
-                suggestions.push(`${scoredFiles.length - 8} additional files with low coverage`);
-            const result = {
-                success: true,
-                task,
-                coverageAware: true,
-                gaps,
-                routing: {
-                    primaryAgent,
-                    confidence: gaps.length > 0 ? 0.85 : 0.6,
-                    reason: gaps.length > 0
-                        ? `Routing to ${primaryAgent} based on ${gaps.length} coverage gaps related to task`
-                        : `No coverage gaps found related to task, routing to ${primaryAgent}`,
-                    coverageImpact: gaps.length > 0 ? 'high' : 'low',
-                },
-                suggestions,
-                metrics: {
-                    filesAnalyzed: diskCoverage.summary.totalFiles,
-                    totalGaps: scoredFiles.length,
-                    criticalGaps,
-                    avgCoverage: diskCoverage.summary.overallLineCoverage,
-                },
-                source: diskCoverage.source,
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.routing.primaryAgent)}`,
-                `Confidence: ${(result.routing.confidence * 100).toFixed(1)}%`,
-                `Coverage-Aware: ${output.success('Yes')} (from ${diskCoverage.source})`,
-                `Reason: ${result.routing.reason}`
-            ].join('\n'), 'Coverage-Aware Routing');
-            if (gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Coverage Gaps'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10 },
-                        { key: 'suggestedAgents', header: 'Agent', width: 15, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: gaps.slice(0, 8)
-                });
-            }
-            if (result.metrics.filesAnalyzed > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Metrics'));
-                output.printList([
-                    `Files Analyzed: ${result.metrics.filesAnalyzed}`,
-                    `Total Gaps: ${result.metrics.totalGaps}`,
-                    `Critical Gaps: ${result.metrics.criticalGaps}`,
-                    `Average Coverage: ${result.metrics.avgCoverage.toFixed(1)}%`
-                ]);
-            }
-            if (suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Suggestions'));
-                output.printList(suggestions.map(s => output.dim(s)));
-            }
-            return { success: true, data: result };
-        }
-        // No disk coverage - fall back to MCP tool
-        try {
-            const result = await callMCPTool('hooks_coverage-route', {
-                task,
-                threshold,
-                useMonovector,
-            });
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Agent: ${output.highlight(result.routing.primaryAgent)}`,
-                `Confidence: ${(result.routing.confidence * 100).toFixed(1)}%`,
-                `Coverage-Aware: ${result.coverageAware ? output.success('Yes') : output.dim('No coverage data')}`,
-                `Reason: ${result.routing.reason}`
-            ].join('\n'), 'Coverage-Aware Routing');
-            if (result.gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Coverage Gaps'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10 },
-                        { key: 'suggestedAgents', header: 'Agent', width: 15, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: result.gaps.slice(0, 8)
-                });
-            }
-            if (result.metrics.filesAnalyzed > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Metrics'));
-                output.printList([
-                    `Files Analyzed: ${result.metrics.filesAnalyzed}`,
-                    `Total Gaps: ${result.metrics.totalGaps}`,
-                    `Critical Gaps: ${result.metrics.criticalGaps}`,
-                    `Average Coverage: ${result.metrics.avgCoverage.toFixed(1)}%`
-                ]);
-            }
-            if (result.suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Suggestions'));
-                output.printList(result.suggestions.map(s => output.dim(s)));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('No coverage data found');
-            output.writeln();
-            output.printWarning('No coverage data found. Run your test suite with coverage first.');
-            output.writeln();
-            output.printList([
-                'Jest:     npx jest --coverage',
-                'Vitest:   npx vitest --coverage',
-                'nyc:      npx nyc npm test',
-                'c8:       npx c8 npm test',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Coverage suggest subcommand
-const coverageSuggestCommand = {
-    name: 'coverage-suggest',
-    description: 'Suggest coverage improvements for a path (monovector integration)',
-    options: [
-        {
-            name: 'path',
-            short: 'p',
-            description: 'Path to analyze for coverage suggestions',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'threshold',
-            description: 'Coverage threshold percentage (default: 80)',
-            type: 'number',
-            default: 80
-        },
-        {
-            name: 'limit',
-            short: 'l',
-            description: 'Maximum number of suggestions (default: 20)',
-            type: 'number',
-            default: 20
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks coverage-suggest -p src/', description: 'Suggest improvements for src/' },
-        { command: 'monomind hooks coverage-suggest -p src/services --threshold 90', description: 'Stricter threshold' }
-    ],
-    action: async (ctx) => {
-        const targetPath = ctx.args[0] || ctx.flags.path;
-        const threshold = ctx.flags.threshold || 80;
-        const limit = ctx.flags.limit || 20;
-        if (!targetPath) {
-            output.printError('Path is required. Use --path or -p flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: `Analyzing coverage for ${targetPath}...` });
-        spinner.start();
-        // Try reading coverage from disk first
-        const diskCoverage = readCoverageFromDisk();
-        if (diskCoverage.found) {
-            spinner.succeed(`Coverage data loaded from ${diskCoverage.source}`);
-            // Filter entries to those matching the target path
-            const pathLower = targetPath.toLowerCase().replace(/\\/g, '/');
-            const matchingEntries = diskCoverage.entries.filter(e => {
-                const fileLower = e.filePath.toLowerCase().replace(/\\/g, '/');
-                return fileLower.includes(pathLower);
-            });
-            const belowThreshold = matchingEntries.filter(e => e.lines < threshold);
-            const suggestions = belowThreshold.slice(0, limit).map(e => {
-                const { gapType, priority } = classifyCoverageGap(e.lines, threshold);
-                return {
-                    filePath: e.filePath,
-                    coveragePercent: e.lines,
-                    gapType,
-                    priority,
-                    suggestedAgents: suggestAgentsForFile(e.filePath),
-                    reason: e.lines === 0 ? 'No coverage at all' :
-                        e.lines < 20 ? 'Very low coverage, needs tests' :
-                            e.lines < 50 ? 'Below 50%, add more tests' :
-                                `Below ${threshold}% threshold`,
-                };
-            });
-            const totalLinesCov = matchingEntries.length > 0
-                ? matchingEntries.reduce((acc, e) => acc + e.lines, 0) / matchingEntries.length
-                : 0;
-            const totalBranchesCov = matchingEntries.length > 0
-                ? matchingEntries.reduce((acc, e) => acc + e.branches, 0) / matchingEntries.length
-                : 0;
-            const prioritizedFiles = belowThreshold.slice(0, 5).map(e => e.filePath);
-            const result = {
-                success: true,
-                path: targetPath,
-                suggestions,
-                summary: {
-                    totalFiles: matchingEntries.length,
-                    overallLineCoverage: totalLinesCov,
-                    overallBranchCoverage: totalBranchesCov,
-                    filesBelowThreshold: belowThreshold.length,
-                },
-                prioritizedFiles,
-                monovectorAvailable: false,
-                source: diskCoverage.source,
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Path: ${output.highlight(targetPath)}`,
-                `Files Analyzed: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below Threshold: ${result.summary.filesBelowThreshold} files`,
-                `Source: ${output.highlight(diskCoverage.source)}`
-            ].join('\n'), 'Coverage Summary');
-            if (suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Improvement Suggestions'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 40, format: (v) => {
-                                const s = String(v);
-                                return s.length > 37 ? '...' + s.slice(-37) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Priority', width: 10 },
-                        { key: 'reason', header: 'Reason', width: 25 }
-                    ],
-                    data: suggestions.slice(0, 15)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('All files meet coverage threshold!');
-            }
-            if (prioritizedFiles.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Files (Top 5)'));
-                output.printList(prioritizedFiles.slice(0, 5).map(f => output.highlight(f)));
-            }
-            return { success: true, data: result };
-        }
-        // No disk coverage - fall back to MCP tool
-        try {
-            const result = await callMCPTool('hooks_coverage-suggest', {
-                path: targetPath,
-                threshold,
-                limit,
-            });
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Path: ${output.highlight(result.path)}`,
-                `Files Analyzed: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below Threshold: ${result.summary.filesBelowThreshold} files`,
-                `Keyword routing: ${result.monovectorAvailable ? output.success('Available') : output.dim('Unavailable')}`
-            ].join('\n'), 'Coverage Summary');
-            if (result.suggestions.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Coverage Improvement Suggestions'));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 40, format: (v) => {
-                                const s = String(v);
-                                return s.length > 37 ? '...' + s.slice(-37) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Priority', width: 10 },
-                        { key: 'reason', header: 'Reason', width: 25 }
-                    ],
-                    data: result.suggestions.slice(0, 15)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('All files meet coverage threshold!');
-            }
-            if (result.prioritizedFiles.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Priority Files (Top 5)'));
-                output.printList(result.prioritizedFiles.slice(0, 5).map(f => output.highlight(f)));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('No coverage data found');
-            output.writeln();
-            output.printWarning('No coverage data found. Run your test suite with coverage first.');
-            output.writeln();
-            output.printList([
-                'Jest:     npx jest --coverage',
-                'Vitest:   npx vitest --coverage',
-                'nyc:      npx nyc npm test',
-                'c8:       npx c8 npm test',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Coverage gaps subcommand
-const coverageGapsCommand = {
-    name: 'coverage-gaps',
-    description: 'List all coverage gaps with priority scoring and agent assignments',
-    options: [
-        {
-            name: 'threshold',
-            description: 'Coverage threshold percentage (default: 80)',
-            type: 'number',
-            default: 80
-        },
-        {
-            name: 'group-by-agent',
-            description: 'Group gaps by suggested agent (default: true)',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'critical-only',
-            description: 'Show only critical gaps',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks coverage-gaps', description: 'List all coverage gaps' },
-        { command: 'monomind hooks coverage-gaps --critical-only', description: 'Only critical gaps' },
-        { command: 'monomind hooks coverage-gaps --threshold 90', description: 'Stricter threshold' }
-    ],
-    action: async (ctx) => {
-        const threshold = ctx.flags.threshold || 80;
-        const groupByAgent = ctx.flags['group-by-agent'] !== false;
-        const criticalOnly = ctx.flags['critical-only'] || false;
-        const spinner = output.createSpinner({ text: 'Analyzing project coverage gaps...' });
-        spinner.start();
-        // Try reading coverage from disk first
-        const diskCoverage = readCoverageFromDisk();
-        if (diskCoverage.found) {
-            spinner.succeed(`Coverage data loaded from ${diskCoverage.source}`);
-            // Build gaps from disk data
-            const allGaps = diskCoverage.entries
-                .filter(e => e.lines < threshold)
-                .map(e => {
-                const { gapType, priority } = classifyCoverageGap(e.lines, threshold);
-                return {
-                    filePath: e.filePath,
-                    coveragePercent: e.lines,
-                    gapType,
-                    complexity: Math.round((100 - e.lines) / 10),
-                    priority,
-                    suggestedAgents: suggestAgentsForFile(e.filePath),
-                    reason: `Line coverage ${e.lines.toFixed(1)}% below ${threshold}% threshold`,
-                };
-            });
-            const gaps = criticalOnly
-                ? allGaps.filter(g => g.gapType === 'critical')
-                : allGaps;
-            // Build agent assignments
-            const agentAssignments = {};
-            if (groupByAgent) {
-                for (const gap of gaps) {
-                    const agent = gap.suggestedAgents[0] || 'tester';
-                    if (!agentAssignments[agent])
-                        agentAssignments[agent] = [];
-                    agentAssignments[agent].push(gap.filePath);
-                }
-            }
-            const result = {
-                success: true,
-                gaps,
-                summary: {
-                    totalFiles: diskCoverage.summary.totalFiles,
-                    overallLineCoverage: diskCoverage.summary.overallLineCoverage,
-                    overallBranchCoverage: diskCoverage.summary.overallBranchCoverage,
-                    filesBelowThreshold: gaps.length,
-                    coverageThreshold: threshold,
-                },
-                agentAssignments,
-                monovectorAvailable: false,
-                source: diskCoverage.source,
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Total Files: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below ${threshold}%: ${result.summary.filesBelowThreshold} files`,
-                `Source: ${output.highlight(diskCoverage.source)}`
-            ].join('\n'), 'Coverage Gap Analysis');
-            if (gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(`Coverage Gaps (${gaps.length} files)`));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10, format: (v) => {
-                                const t = String(v);
-                                if (t === 'critical')
-                                    return output.error(t);
-                                if (t === 'high')
-                                    return output.warning(t);
-                                return t;
-                            } },
-                        { key: 'priority', header: 'Priority', width: 8, align: 'right' },
-                        { key: 'suggestedAgents', header: 'Agent', width: 12, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: gaps.slice(0, 20)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('No coverage gaps found! All files meet threshold.');
-            }
-            if (groupByAgent && Object.keys(agentAssignments).length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Agent Assignments'));
-                for (const [agent, files] of Object.entries(agentAssignments)) {
-                    output.writeln();
-                    output.writeln(`  ${output.highlight(agent)} (${files.length} files)`);
-                    files.slice(0, 3).forEach(f => {
-                        output.writeln(`    - ${output.dim(f)}`);
-                    });
-                    if (files.length > 3) {
-                        output.writeln(`    ... and ${files.length - 3} more`);
-                    }
-                }
-            }
-            return { success: true, data: result };
-        }
-        // No coverage files on disk - try MCP tool as fallback
-        try {
-            const result = await callMCPTool('hooks_coverage-gaps', {
-                threshold,
-                groupByAgent,
-            });
-            spinner.stop();
-            const gaps = criticalOnly
-                ? result.gaps.filter(g => g.gapType === 'critical')
-                : result.gaps;
-            if (ctx.flags.format === 'json') {
-                output.printJson({ ...result, gaps });
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.printBox([
-                `Total Files: ${result.summary.totalFiles}`,
-                `Line Coverage: ${result.summary.overallLineCoverage.toFixed(1)}%`,
-                `Branch Coverage: ${result.summary.overallBranchCoverage.toFixed(1)}%`,
-                `Below ${result.summary.coverageThreshold}%: ${result.summary.filesBelowThreshold} files`,
-                `Keyword routing: ${result.monovectorAvailable ? output.success('Available') : output.dim('Unavailable')}`
-            ].join('\n'), 'Coverage Gap Analysis');
-            if (gaps.length > 0) {
-                output.writeln();
-                output.writeln(output.bold(`Coverage Gaps (${gaps.length} files)`));
-                output.printTable({
-                    columns: [
-                        { key: 'filePath', header: 'File', width: 35, format: (v) => {
-                                const s = String(v);
-                                return s.length > 32 ? '...' + s.slice(-32) : s;
-                            } },
-                        { key: 'coveragePercent', header: 'Coverage', width: 10, align: 'right', format: (v) => `${Number(v).toFixed(1)}%` },
-                        { key: 'gapType', header: 'Type', width: 10, format: (v) => {
-                                const t = String(v);
-                                if (t === 'critical')
-                                    return output.error(t);
-                                if (t === 'high')
-                                    return output.warning(t);
-                                return t;
-                            } },
-                        { key: 'priority', header: 'Priority', width: 8, align: 'right' },
-                        { key: 'suggestedAgents', header: 'Agent', width: 12, format: (v) => Array.isArray(v) ? v[0] || '' : String(v) }
-                    ],
-                    data: gaps.slice(0, 20)
-                });
-            }
-            else {
-                output.writeln();
-                output.printSuccess('No coverage gaps found! All files meet threshold.');
-            }
-            if (groupByAgent && Object.keys(result.agentAssignments).length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Agent Assignments'));
-                for (const [agent, files] of Object.entries(result.agentAssignments)) {
-                    output.writeln();
-                    output.writeln(`  ${output.highlight(agent)} (${files.length} files)`);
-                    files.slice(0, 3).forEach(f => {
-                        output.writeln(`    - ${output.dim(f)}`);
-                    });
-                    if (files.length > 3) {
-                        output.writeln(`    ... and ${files.length - 3} more`);
-                    }
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('No coverage data found');
-            output.writeln();
-            output.printWarning('No coverage data found. Run your test suite with coverage first.');
-            output.writeln();
-            output.printList([
-                'Jest:     npx jest --coverage',
-                'Vitest:   npx vitest --coverage',
-                'nyc:      npx nyc npm test',
-                'c8:       npx c8 npm test',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Expected files: coverage/coverage-summary.json, coverage/lcov.info, or .nyc_output/out.json'));
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Progress hook command
-const progressHookCommand = {
-    name: 'progress',
-    description: 'Check implementation progress via hooks',
-    options: [
-        {
-            name: 'detailed',
-            short: 'd',
-            description: 'Show detailed breakdown by category',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'sync',
-            short: 's',
-            description: 'Sync and persist progress to file',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'summary',
-            description: 'Show human-readable summary',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks progress', description: 'Check current progress' },
-        { command: 'monomind hooks progress -d', description: 'Detailed breakdown' },
-        { command: 'monomind hooks progress --sync', description: 'Sync progress to file' },
-        { command: 'monomind hooks progress --summary', description: 'Human-readable summary' }
-    ],
-    action: async (ctx) => {
-        const detailed = ctx.flags.detailed;
-        const sync = ctx.flags.sync;
-        const summary = ctx.flags.summary;
-        try {
-            if (summary) {
-                const spinner = output.createSpinner({ text: 'Getting progress summary...' });
-                spinner.start();
-                const result = await callMCPTool('progress_summary', {});
-                spinner.stop();
-                if (ctx.flags.format === 'json') {
-                    output.printJson(result);
-                    return { success: true, data: result };
-                }
-                output.writeln();
-                output.writeln(result.summary);
-                return { success: true, data: result };
-            }
-            if (sync) {
-                const spinner = output.createSpinner({ text: 'Syncing progress...' });
-                spinner.start();
-                const result = await callMCPTool('progress_sync', {});
-                spinner.stop();
-                if (ctx.flags.format === 'json') {
-                    output.printJson(result);
-                    return { success: true, data: result };
-                }
-                output.writeln();
-                output.printSuccess(`Progress synced: ${result.progress}%`);
-                output.writeln(output.dim(`  Persisted to .monomind/metrics/v1-progress.json`));
-                output.writeln(output.dim(`  Last updated: ${result.lastUpdated}`));
-                return { success: true, data: result };
-            }
-            // Default: check progress
-            const spinner = output.createSpinner({ text: 'Checking v1 progress...' });
-            spinner.start();
-            const result = await callMCPTool('progress_check', { detailed });
-            spinner.stop();
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            const progressValue = result.overall ?? result.progress ?? 0;
-            // Create progress bar
-            const barWidth = 30;
-            const filled = Math.round((progressValue / 100) * barWidth);
-            const empty = barWidth - filled;
-            const bar = output.success('█'.repeat(filled)) + output.dim('░'.repeat(empty));
-            output.writeln(output.bold('v1 Implementation Progress'));
-            output.writeln();
-            output.writeln(`[${bar}] ${progressValue}%`);
-            output.writeln();
-            if (detailed && result.cli) {
-                output.writeln(output.highlight('CLI Commands:') + `     ${result.cli.progress}% (${result.cli.commands}/${result.cli.target})`);
-                output.writeln(output.highlight('MCP Tools:') + `        ${result.mcp?.progress ?? 0}% (${result.mcp?.tools ?? 0}/${result.mcp?.target ?? 0})`);
-                output.writeln(output.highlight('Hooks:') + `            ${result.hooks?.progress ?? 0}% (${result.hooks?.subcommands ?? 0}/${result.hooks?.target ?? 0})`);
-                output.writeln(output.highlight('Packages:') + `         ${result.packages?.progress ?? 0}% (${result.packages?.total ?? 0}/${result.packages?.target ?? 0})`);
-                output.writeln(output.highlight('DDD Structure:') + `    ${result.ddd?.progress ?? 0}% (${result.packages?.withDDD ?? 0}/${result.packages?.total ?? 0})`);
-                output.writeln();
-                if (result.codebase) {
-                    output.writeln(output.dim(`Codebase: ${result.codebase.totalFiles} files, ${result.codebase.totalLines.toLocaleString()} lines`));
-                }
-            }
-            else if (result.breakdown) {
-                output.writeln('Breakdown:');
-                for (const [category, value] of Object.entries(result.breakdown)) {
-                    output.writeln(`  ${output.highlight(category)}: ${value}`);
-                }
-            }
-            if (result.lastUpdated) {
-                output.writeln(output.dim(`Last updated: ${result.lastUpdated}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Progress check failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Progress check failed: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Worker parent command
-const workerCommand = {
-    name: 'worker',
-    description: 'Background worker management (12 workers for analysis/optimization)',
-    subcommands: [
-        workerListCommand,
-        workerDispatchCommand,
-        workerStatusCommand,
-        workerDetectCommand,
-        workerCancelCommand,
-    ],
-    options: [],
-    examples: [
-        { command: 'monomind hooks worker list', description: 'List all workers' },
-        { command: 'monomind hooks worker dispatch -t optimize', description: 'Dispatch optimizer' },
-        { command: 'monomind hooks worker detect -p "test coverage"', description: 'Detect from prompt' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Background Worker System (12 Workers)'));
-        output.writeln();
-        output.writeln('Manage and dispatch background workers for analysis and optimization tasks.');
-        output.writeln();
-        output.writeln('Available Workers:');
-        output.printList([
-            `${output.highlight('ultralearn')}   - Deep knowledge acquisition`,
-            `${output.highlight('optimize')}     - Performance optimization`,
-            `${output.highlight('consolidate')} - Memory consolidation`,
-            `${output.highlight('predict')}      - Predictive preloading`,
-            `${output.highlight('audit')}        - Security analysis (critical)`,
-            `${output.highlight('map')}          - Codebase mapping`,
-            `${output.highlight('preload')}      - Resource preloading`,
-            `${output.highlight('deepdive')}     - Deep code analysis`,
-            `${output.highlight('document')}     - Auto-documentation`,
-            `${output.highlight('refactor')}     - Refactoring suggestions`,
-            `${output.highlight('benchmark')}    - Performance benchmarks`,
-            `${output.highlight('testgaps')}     - Test coverage analysis`,
-        ]);
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('list')}     - List all workers with capabilities`,
-            `${output.highlight('dispatch')} - Dispatch a worker`,
-            `${output.highlight('status')}   - Check worker status`,
-            `${output.highlight('detect')}   - Detect triggers from prompt`,
-            `${output.highlight('cancel')}   - Cancel a running worker`,
-        ]);
-        output.writeln();
-        output.writeln('Run "monomind hooks worker <subcommand> --help" for details');
-        return { success: true };
-    }
-};
-// Statusline subcommand - generates dynamic status display
-const statuslineCommand = {
-    name: 'statusline',
-    description: 'Generate dynamic statusline with v1 progress and system status',
-    options: [
-        {
-            name: 'json',
-            description: 'Output as JSON',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'compact',
-            description: 'Compact single-line output',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'no-color',
-            description: 'Disable ANSI colors',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind hooks statusline', description: 'Display full statusline' },
-        { command: 'monomind hooks statusline --json', description: 'JSON output for hooks' },
-        { command: 'monomind hooks statusline --compact', description: 'Single-line status' }
-    ],
-    action: async (ctx) => {
-        const fs = await import('fs');
-        const path = await import('path');
-        const { execSync } = await import('child_process');
-        // Get learning stats from memory database
-        function getLearningStats() {
-            const memoryPaths = [
-                path.join(process.cwd(), '.swarm', 'memory.db'),
-                path.join(process.cwd(), '.claude', 'memory.db'),
-            ];
-            let patterns = 0;
-            let sessions = 0;
-            let trajectories = 0;
-            for (const dbPath of memoryPaths) {
-                if (fs.existsSync(dbPath)) {
-                    try {
-                        const stats = fs.statSync(dbPath);
-                        const sizeKB = stats.size / 1024;
-                        patterns = Math.floor(sizeKB / 2);
-                        sessions = Math.max(1, Math.floor(patterns / 10));
-                        trajectories = Math.floor(patterns / 5);
-                        break;
-                    }
-                    catch {
-                        // Ignore
-                    }
-                }
-            }
-            const sessionsPath = path.join(process.cwd(), '.claude', 'sessions');
-            if (fs.existsSync(sessionsPath)) {
-                try {
-                    const sessionFiles = fs.readdirSync(sessionsPath).filter((f) => f.endsWith('.json'));
-                    sessions = Math.max(sessions, sessionFiles.length);
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            return { patterns, sessions, trajectories };
-        }
-        // Get v1 progress
-        function getv1Progress() {
-            const learning = getLearningStats();
-            let domainsCompleted = 0;
-            if (learning.patterns >= 500)
-                domainsCompleted = 5;
-            else if (learning.patterns >= 200)
-                domainsCompleted = 4;
-            else if (learning.patterns >= 100)
-                domainsCompleted = 3;
-            else if (learning.patterns >= 50)
-                domainsCompleted = 2;
-            else if (learning.patterns >= 10)
-                domainsCompleted = 1;
-            const totalDomains = 5;
-            const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
-            return { domainsCompleted, totalDomains, dddProgress, patternsLearned: learning.patterns, sessionsCompleted: learning.sessions };
-        }
-        // Get security status
-        function getSecurityStatus() {
-            const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
-            let cvesFixed = 0;
-            const totalCves = 3;
-            if (fs.existsSync(scanResultsPath)) {
-                try {
-                    const scans = fs.readdirSync(scanResultsPath).filter((f) => f.endsWith('.json'));
-                    cvesFixed = Math.min(totalCves, scans.length);
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            const auditPath = path.join(process.cwd(), '.swarm', 'security');
-            if (fs.existsSync(auditPath)) {
-                try {
-                    const audits = fs.readdirSync(auditPath).filter((f) => f.includes('audit'));
-                    cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
-            return { status, cvesFixed, totalCves };
-        }
-        // Get swarm status
-        function getSwarmStatus() {
-            let activeAgents = 0;
-            let coordinationActive = false;
-            const maxAgents = 15;
-            const isWindows = process.platform === 'win32';
-            try {
-                const psCmd = isWindows
-                    ? 'tasklist /FI "IMAGENAME eq node.exe" 2>NUL | findstr /I /C:"node" >NUL && echo 1 || echo 0'
-                    : 'ps aux 2>/dev/null | grep -c agentic-flow || echo "0"';
-                const ps = execSync(psCmd, { encoding: 'utf-8' });
-                const raw = parseInt(ps.trim());
-                activeAgents = Math.max(0, isWindows ? raw : raw - 1);
-                coordinationActive = activeAgents > 0;
-            }
-            catch {
-                // Ignore
-            }
-            return { activeAgents, maxAgents, coordinationActive };
-        }
-        // Get system metrics
-        function getSystemMetrics() {
-            let memoryMB = 0;
-            let subAgents = 0;
-            const learning = getLearningStats();
-            try {
-                memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
-            }
-            catch {
-                // Ignore
-            }
-            // Calculate intelligence from multiple sources (matching statusline-generator.ts)
-            let intelligencePct = 0;
-            // 1. Check learning.json for REAL intelligence metrics first
-            const learningJsonPaths = [
-                path.join(process.cwd(), '.monomind', 'learning.json'),
-                path.join(process.cwd(), '.claude', '.monomind', 'learning.json'),
-                path.join(process.cwd(), '.swarm', 'learning.json'),
-            ];
-            for (const lPath of learningJsonPaths) {
-                if (fs.existsSync(lPath)) {
-                    try {
-                        if (fs.statSync(lPath).size <= 524_288) {
-                            const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
-                            if (data.intelligence?.score !== undefined) {
-                                intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
-                                break;
-                            }
-                        }
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-            // 2. Fallback: calculate from patterns and vectors
-            if (intelligencePct === 0) {
-                const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 10)) : 0;
-                // Will be updated later with vector count
-                intelligencePct = fromPatterns;
-            }
-            // 3. Fallback: calculate maturity score from project indicators
-            if (intelligencePct === 0) {
-                let maturityScore = 0;
-                // Check for key project files/dirs
-                if (fs.existsSync(path.join(process.cwd(), '.claude')))
-                    maturityScore += 15;
-                if (fs.existsSync(path.join(process.cwd(), '.monomind')))
-                    maturityScore += 15;
-                if (fs.existsSync(path.join(process.cwd(), 'CLAUDE.md')))
-                    maturityScore += 10;
-                if (fs.existsSync(path.join(process.cwd(), 'monomind.config.json')))
-                    maturityScore += 10;
-                if (fs.existsSync(path.join(process.cwd(), '.swarm')))
-                    maturityScore += 10;
-                // Check for test files
-                const testDirs = ['tests', '__tests__', 'test', 'v1/__tests__'];
-                for (const dir of testDirs) {
-                    if (fs.existsSync(path.join(process.cwd(), dir))) {
-                        maturityScore += 10;
-                        break;
-                    }
-                }
-                // Check for hooks config
-                if (fs.existsSync(path.join(process.cwd(), '.claude', 'settings.json')))
-                    maturityScore += 10;
-                intelligencePct = Math.min(100, maturityScore);
-            }
-            const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
-            return { memoryMB, contextPct, intelligencePct, subAgents };
-        }
-        // Get user info
-        function getUserInfo() {
-            let name = 'user';
-            let gitBranch = '';
-            const modelName = 'Opus 4.6 (1M context)';
-            const isWindows = process.platform === 'win32';
-            try {
-                const nameCmd = isWindows
-                    ? 'git config user.name 2>NUL || echo user'
-                    : 'git config user.name 2>/dev/null || echo "user"';
-                const branchCmd = isWindows
-                    ? 'git branch --show-current 2>NUL || echo.'
-                    : 'git branch --show-current 2>/dev/null || echo ""';
-                name = execSync(nameCmd, { encoding: 'utf-8' }).trim();
-                gitBranch = execSync(branchCmd, { encoding: 'utf-8' }).trim();
-                if (gitBranch === '.')
-                    gitBranch = '';
-            }
-            catch {
-                // Ignore
-            }
-            return { name, gitBranch, modelName };
-        }
-        // Collect all status
-        const progress = getv1Progress();
-        const security = getSecurityStatus();
-        const swarm = getSwarmStatus();
-        const system = getSystemMetrics();
-        const user = getUserInfo();
-        const statusData = {
-            user,
-            v1Progress: progress,
-            security,
-            swarm,
-            system,
-            timestamp: new Date().toISOString()
-        };
-        // JSON output
-        if (ctx.flags.json || ctx.flags.format === 'json') {
-            output.printJson(statusData);
-            return { success: true, data: statusData };
-        }
-        // Compact output
-        if (ctx.flags.compact) {
-            const line = `DDD:${progress.domainsCompleted}/${progress.totalDomains} CVE:${security.cvesFixed}/${security.totalCves} Swarm:${swarm.activeAgents}/${swarm.maxAgents} Ctx:${system.contextPct}% Int:${system.intelligencePct}%`;
-            output.writeln(line);
-            return { success: true, data: statusData };
-        }
-        // Full colored output
-        const noColor = ctx.flags['no-color'] || ctx.flags.noColor;
-        const c = noColor ? {
-            reset: '', bold: '', dim: '', red: '', green: '', yellow: '', blue: '',
-            purple: '', cyan: '', brightRed: '', brightGreen: '', brightYellow: '',
-            brightBlue: '', brightPurple: '', brightCyan: '', brightWhite: ''
-        } : {
-            reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m', red: '\x1b[0;31m',
-            green: '\x1b[0;32m', yellow: '\x1b[0;33m', blue: '\x1b[0;34m',
-            purple: '\x1b[0;35m', cyan: '\x1b[0;36m', brightRed: '\x1b[1;31m',
-            brightGreen: '\x1b[1;32m', brightYellow: '\x1b[1;33m', brightBlue: '\x1b[1;34m',
-            brightPurple: '\x1b[1;35m', brightCyan: '\x1b[1;36m', brightWhite: '\x1b[1;37m'
-        };
-        // Progress bar helper
-        const progressBar = (current, total) => {
-            const filled = Math.round((current / total) * 5);
-            const empty = 5 - filled;
-            return '[' + '●'.repeat(filled) + '○'.repeat(empty) + ']';
-        };
-        // Generate lines
-        let header = `${c.bold}${c.brightPurple}▊ Monomind ${c.reset}`;
-        header += `${swarm.coordinationActive ? c.brightCyan : c.dim}● ${c.brightCyan}${user.name}${c.reset}`;
-        if (user.gitBranch) {
-            header += `  ${c.dim}│${c.reset}  ${c.brightBlue}⎇ ${user.gitBranch}${c.reset}`;
-        }
-        header += `  ${c.dim}│${c.reset}  ${c.purple}${user.modelName}${c.reset}`;
-        const separator = `${c.dim}─────────────────────────────────────────────────────${c.reset}`;
-        // Get hooks stats
-        const hooksStats = { enabled: 0, total: 17 };
-        const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
-        if (fs.existsSync(settingsPath)) {
-            try {
-                if (fs.statSync(settingsPath).size <= 524_288) {
-                    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                    if (settings.hooks) {
-                        hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
-                    }
-                }
-            }
-            catch { /* ignore */ }
-        }
-        // Get AgentDB stats (matching statusline-generator.ts paths)
-        const agentdbStats = { vectorCount: 0, dbSizeKB: 0, hasHnsw: false };
-        // Check for direct database files first
-        const dbPaths = [
-            path.join(process.cwd(), '.swarm', 'memory.db'),
-            path.join(process.cwd(), '.monomind', 'memory.db'),
-            path.join(process.cwd(), '.claude', 'memory.db'),
-            path.join(process.cwd(), 'data', 'memory.db'),
-            path.join(process.cwd(), 'memory.db'),
-            path.join(process.cwd(), '.agentdb', 'memory.db'),
-            path.join(process.cwd(), '.monomind', 'memory', 'agentdb.db'),
-        ];
-        for (const dbPath of dbPaths) {
-            if (fs.existsSync(dbPath)) {
-                try {
-                    const stats = fs.statSync(dbPath);
-                    agentdbStats.dbSizeKB = Math.round(stats.size / 1024);
-                    agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
-                    agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
-                    break;
-                }
-                catch { /* ignore */ }
-            }
-        }
-        // Check for AgentDB directories if no direct db found
-        if (agentdbStats.vectorCount === 0) {
-            const agentdbDirs = [
-                path.join(process.cwd(), '.monomind', 'agentdb'),
-                path.join(process.cwd(), '.swarm', 'agentdb'),
-                path.join(process.cwd(), 'data', 'agentdb'),
-                path.join(process.cwd(), '.agentdb'),
-            ];
-            for (const dir of agentdbDirs) {
-                if (fs.existsSync(dir)) {
-                    try {
-                        const files = fs.readdirSync(dir);
-                        for (const f of files) {
-                            if (f.endsWith('.db') || f.endsWith('.sqlite')) {
-                                const filePath = path.join(dir, f);
-                                const fileStat = fs.statSync(filePath);
-                                agentdbStats.dbSizeKB += Math.round(fileStat.size / 1024);
-                            }
-                        }
-                        agentdbStats.vectorCount = Math.floor(agentdbStats.dbSizeKB / 2);
-                        agentdbStats.hasHnsw = agentdbStats.vectorCount > 100;
-                        if (agentdbStats.vectorCount > 0)
-                            break;
-                    }
-                    catch { /* ignore */ }
-                }
-            }
-        }
-        // Check for HNSW index files
-        const hnswPaths = [
-            path.join(process.cwd(), '.monomind', 'hnsw'),
-            path.join(process.cwd(), '.swarm', 'hnsw'),
-            path.join(process.cwd(), 'data', 'hnsw'),
-        ];
-        for (const hnswPath of hnswPaths) {
-            if (fs.existsSync(hnswPath)) {
-                agentdbStats.hasHnsw = true;
-                try {
-                    const hnswFiles = fs.readdirSync(hnswPath);
-                    const indexFile = hnswFiles.find(f => f.endsWith('.index'));
-                    if (indexFile) {
-                        const indexStat = fs.statSync(path.join(hnswPath, indexFile));
-                        const hnswVectors = Math.floor(indexStat.size / 512);
-                        agentdbStats.vectorCount = Math.max(agentdbStats.vectorCount, hnswVectors);
-                    }
-                }
-                catch { /* ignore */ }
-                break;
-            }
-        }
-        // Check for vectors.json file
-        const vectorsPath = path.join(process.cwd(), '.monomind', 'vectors.json');
-        if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
-            try {
-                if (fs.statSync(vectorsPath).size <= 8_388_608) {
-                    const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
-                    if (Array.isArray(data)) {
-                        agentdbStats.vectorCount = data.length;
-                    }
-                    else if (data.vectors) {
-                        agentdbStats.vectorCount = Object.keys(data.vectors).length;
-                    }
-                }
-            }
-            catch { /* ignore */ }
-        }
-        // Get test stats
-        const testStats = { testFiles: 0, testCases: 0 };
-        const testPaths = ['tests', '__tests__', 'test', 'spec'];
-        for (const testPath of testPaths) {
-            const fullPath = path.join(process.cwd(), testPath);
-            if (fs.existsSync(fullPath)) {
-                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; // Estimate
-                }
-                catch { /* ignore */ }
-            }
-        }
-        // Get MCP stats
-        const mcpStats = { enabled: 0, total: 0 };
-        const mcpPath = path.join(process.cwd(), '.mcp.json');
-        if (fs.existsSync(mcpPath)) {
-            try {
-                const mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
-                if (mcp.mcpServers) {
-                    mcpStats.total = Object.keys(mcp.mcpServers).length;
-                    mcpStats.enabled = mcpStats.total;
-                }
-            }
-            catch { /* ignore */ }
-        }
-        const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
-        // Dynamic perf indicator based on patterns/HNSW
-        let perfIndicator = `${c.dim}⚡ HNSW: idle${c.reset}`;
-        if (agentdbStats.hasHnsw && agentdbStats.vectorCount > 0) {
-            perfIndicator = `${c.brightGreen}⚡ HNSW ${agentdbStats.vectorCount.toLocaleString()} vec${c.reset}`;
-        }
-        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}`;
-        }
-        const line1 = `${c.brightCyan}🏗️  DDD Domains${c.reset}    ${progressBar(progress.domainsCompleted, progress.totalDomains)}  ` +
-            `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset}    ` +
-            perfIndicator;
-        const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}◉${c.reset}` : `${c.dim}○${c.reset}`;
-        const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
-        const securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
-        const securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
-        const hooksColor = hooksStats.enabled > 0 ? c.brightGreen : c.dim;
-        const line2 = `${c.brightYellow}🤖 Swarm${c.reset}  ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]  ` +
-            `${c.brightPurple}👥 ${system.subAgents}${c.reset}    ` +
-            `${c.brightBlue}🪝 ${hooksColor}${hooksStats.enabled}${c.reset}/${c.brightWhite}${hooksStats.total}${c.reset}    ` +
-            `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset}    ` +
-            `${c.brightCyan}💾 ${system.memoryMB}MB${c.reset}    ` +
-            `${c.brightPurple}🧠 ${String(system.intelligencePct).padStart(3)}%${c.reset}`;
-        const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
-        const line3 = `${c.brightPurple}🔧 Architecture${c.reset}    ` +
-            `${c.cyan}ADRs${c.reset} ${c.dim}●0/0${c.reset}  ${c.dim}│${c.reset}  ` +
-            `${c.cyan}DDD${c.reset} ${dddColor}●${String(progress.dddProgress).padStart(3)}%${c.reset}  ${c.dim}│${c.reset}  ` +
-            `${c.cyan}Security${c.reset} ${securityColor}●${security.status}${c.reset}`;
-        const vectorColor = agentdbStats.vectorCount > 0 ? c.brightGreen : c.dim;
-        const testColor = testStats.testFiles > 0 ? c.brightGreen : c.dim;
-        const mcpColor = mcpStats.enabled > 0 ? c.brightGreen : c.dim;
-        const sizeDisplay = agentdbStats.dbSizeKB >= 1024 ? `${(agentdbStats.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdbStats.dbSizeKB}KB`;
-        const hnswIndicator = agentdbStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
-        const line4 = `${c.brightCyan}📊 AgentDB${c.reset}    ` +
-            `${c.cyan}Vectors${c.reset} ${vectorColor}●${agentdbStats.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}MCP${c.reset} ${mcpColor}●${mcpStats.enabled}/${mcpStats.total}${c.reset}`;
-        output.writeln(header);
-        output.writeln(separator);
-        output.writeln(line1);
-        output.writeln(line2);
-        output.writeln(line3);
-        output.writeln(line4);
-        return { success: true, data: statusData };
-    }
-};
-// Backward-compatible aliases for v2 hooks
-// These ensure old settings.json files continue to work
-const routeTaskCommand = {
-    name: 'route-task',
-    description: '(DEPRECATED: Use "route" instead) Route task to optimal agent',
-    options: routeCommand.options,
+// Backward-compatible aliases for v2 hooks
+// These ensure old settings.json files continue to work
+const routeTaskCommand = {
+    name: 'route-task',
+    description: '(DEPRECATED: Use "route" instead) Route task to optimal agent',
+    options: routeCommand.options,
     examples: [
         { command: 'monomind hooks route-task --auto-swarm true', description: 'Route with auto-swarm (v2 compat)' },
     ],
@@ -3753,577 +400,6 @@ const postBashCommand = {
     examples: postCommandCommand.examples,
     action: postCommandCommand.action
 };
-// Token Optimizer command - integrates agentic-flow Agent Booster
-const tokenOptimizeCommand = {
-    name: 'token-optimize',
-    description: 'Token optimization via agentic-flow Agent Booster (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 agentic-flow integration...', spinner: 'dots' });
-        spinner.start();
-        // Inline TokenOptimizer (self-contained, no external imports)
-        const stats = {
-            totalTokensSaved: 0,
-            editsOptimized: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            memoriesRetrieved: 0,
-        };
-        let agenticFlowAvailable = false;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let reasoningBank = null;
-        try {
-            // Check if agentic-flow v1 is available
-            const rb = await import('agentic-flow/reasoningbank').catch(() => null);
-            if (rb) {
-                agenticFlowAvailable = true;
-                if (typeof rb.retrieveMemories === 'function') {
-                    reasoningBank = rb;
-                }
-            }
-            else {
-                // Legacy check for older agentic-flow
-                const af = await import('agentic-flow').catch(() => null);
-                if (af)
-                    agenticFlowAvailable = true;
-            }
-            const versionLabel = agenticFlowAvailable ? `agentic-flow v1 detected (ReasoningBank: ${reasoningBank ? 'active' : 'unavailable'})` : 'agentic-flow not available (using fallbacks)';
-            spinner.succeed(versionLabel);
-            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 provided, get compact context via ReasoningBank
-            if (query && reasoningBank) {
-                output.writeln();
-                output.printInfo(`Retrieving compact context for: "${query}"`);
-                const memories = await reasoningBank.retrieveMemories(query, { k: 5 });
-                const compactPrompt = reasoningBank.formatMemoriesForPrompt ? reasoningBank.formatMemoriesForPrompt(memories) : '';
-                // Estimate based on actual query vs compact prompt size difference
-                const queryTokenEstimate = Math.ceil((query?.length || 0) / 4);
-                const used = Math.ceil((compactPrompt?.length || 0) / 4);
-                const tokensSaved = Math.max(0, queryTokenEstimate - used);
-                stats.totalTokensSaved += tokensSaved;
-                stats.memoriesRetrieved += Array.isArray(memories) ? memories.length : 0;
-                output.writeln(`  Memories found: ${Array.isArray(memories) ? memories.length : 0}`);
-                output.writeln(`  Tokens saved: ${output.success(String(tokensSaved))}`);
-                if (compactPrompt) {
-                    output.writeln(`  Compact prompt (${compactPrompt.length} chars)`);
-                }
-            }
-            else if (query) {
-                output.writeln();
-                output.printInfo('ReasoningBank not available - query skipped');
-            }
-            // 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}` },
-                        { metric: 'Agentic-Flow Active', value: agenticFlowAvailable ? '✓' : '✗' },
-                    ],
-                });
-            }
-            // 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} |
-| Agentic-Flow Active | ${agenticFlowAvailable ? '✓' : '✗'} |`);
-            }
-            return { success: true, data: { config, stats: { ...stats, agenticFlowAvailable } } };
-        }
-        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)
-const modelRouteCommand = {
-    name: 'model-route',
-    description: 'Route task to optimal Claude model (haiku/sonnet/opus) based on complexity',
-    options: [
-        { name: 'task', short: 't', type: 'string', description: 'Task description to route', required: true },
-        { name: 'context', short: 'c', type: 'string', description: 'Additional context' },
-        { name: 'prefer-cost', type: 'boolean', description: 'Prefer lower cost models' },
-        { name: 'prefer-quality', type: 'boolean', description: 'Prefer higher quality models' },
-    ],
-    examples: [
-        { command: 'monomind hooks model-route -t "fix typo"', description: 'Route simple task (likely haiku)' },
-        { command: 'monomind hooks model-route -t "architect auth system"', description: 'Route complex task (likely opus)' },
-    ],
-    action: async (ctx) => {
-        const task = ctx.args[0] || ctx.flags.task;
-        if (!task) {
-            output.printError('Task description required. Use --task or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Analyzing task complexity: ${output.highlight(task.slice(0, 50))}...`);
-        try {
-            const result = await callMCPTool('hooks_model-route', {
-                task,
-                context: ctx.flags.context,
-                preferCost: ctx.flags['prefer-cost'],
-                preferQuality: ctx.flags['prefer-quality'],
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            // Model icon based on selection
-            const modelIcons = {
-                haiku: '🌸',
-                sonnet: '📜',
-                opus: '🎭',
-            };
-            const model = result.model || 'sonnet';
-            const icon = modelIcons[model] || '🤖';
-            // Calculate cost savings compared to opus
-            const costMultipliers = { haiku: 0.04, sonnet: 0.2, opus: 1.0 };
-            const costSavings = model !== 'opus'
-                ? `${((1 - costMultipliers[model]) * 100).toFixed(0)}% vs opus`
-                : undefined;
-            // Determine complexity level
-            const complexityScore = typeof result.complexity === 'number' ? result.complexity : 0.5;
-            const complexityLevel = complexityScore > 0.7 ? 'high' : complexityScore > 0.4 ? 'medium' : 'low';
-            output.printBox([
-                `Selected Model: ${icon} ${output.bold(model.toUpperCase())}`,
-                `Confidence: ${(result.confidence * 100).toFixed(1)}%`,
-                `Complexity: ${complexityLevel} (${(complexityScore * 100).toFixed(0)}%)`,
-                costSavings ? `Cost Savings: ${costSavings}` : '',
-            ].filter(Boolean).join('\n'), 'Model Routing Result');
-            output.writeln();
-            output.writeln(output.bold('Reasoning'));
-            output.writeln(output.dim(result.reasoning || 'Based on task complexity analysis'));
-            if (result.implementation) {
-                output.writeln();
-                output.writeln(output.dim(`Implementation: ${result.implementation}`));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Model routing failed: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Model Outcome command - record routing outcomes for learning
-const modelOutcomeCommand = {
-    name: 'model-outcome',
-    description: 'Record model routing outcome for learning',
-    options: [
-        { name: 'task', short: 't', type: 'string', description: 'Task that was executed', required: true },
-        { name: 'model', short: 'm', type: 'string', description: 'Model that was used (haiku/sonnet/opus)', required: true },
-        { name: 'outcome', short: 'o', type: 'string', description: 'Outcome (success/failure/escalated)', required: true },
-        { name: 'quality', short: 'q', type: 'number', description: 'Quality score 0-1' },
-    ],
-    examples: [
-        { command: 'monomind hooks model-outcome -t "fix typo" -m haiku -o success', description: 'Record successful haiku task' },
-        { command: 'monomind hooks model-outcome -t "auth system" -m sonnet -o escalated', description: 'Record escalation to opus' },
-    ],
-    action: async (ctx) => {
-        const task = ctx.flags.task;
-        const model = ctx.flags.model;
-        const outcome = ctx.flags.outcome;
-        if (!task || !model || !outcome) {
-            output.printError('Task, model, and outcome are required.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('hooks_model-outcome', {
-                task,
-                model,
-                outcome,
-                quality: ctx.flags.quality,
-            });
-            output.printSuccess(`Outcome recorded for ${model}: ${outcome}`);
-            if (result.learningUpdate) {
-                output.writeln(output.dim(result.learningUpdate));
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Failed to record outcome: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Model Stats command - view routing statistics
-const modelStatsCommand = {
-    name: 'model-stats',
-    description: 'View model routing statistics and learning metrics',
-    options: [
-        { name: 'detailed', short: 'd', type: 'boolean', description: 'Show detailed breakdown' },
-    ],
-    examples: [
-        { command: 'monomind hooks model-stats', description: 'View routing stats' },
-        { command: 'monomind hooks model-stats --detailed', description: 'Show detailed breakdown' },
-    ],
-    action: async (ctx) => {
-        try {
-            const result = await callMCPTool('hooks_model-stats', {
-                detailed: ctx.flags.detailed,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            if (!result.available) {
-                output.printWarning(result.message || 'Model router not available');
-                return { success: true, data: result };
-            }
-            // Calculate cost savings based on model distribution
-            const dist = result.modelDistribution || { haiku: 0, sonnet: 0, opus: 0 };
-            const totalTasks = result.totalDecisions || 0;
-            const costMultipliers = { haiku: 0.04, sonnet: 0.2, opus: 1.0 };
-            let totalCost = 0;
-            let maxCost = totalTasks; // If all were opus
-            for (const [model, count] of Object.entries(dist)) {
-                if (model !== 'inherit') {
-                    totalCost += count * (costMultipliers[model] || 1);
-                }
-            }
-            const costSavings = maxCost > 0 ? ((1 - totalCost / maxCost) * 100).toFixed(1) : '0';
-            output.writeln();
-            output.printBox([
-                `Total Tasks Routed: ${totalTasks}`,
-                `Avg Complexity: ${((result.avgComplexity || 0) * 100).toFixed(1)}%`,
-                `Avg Confidence: ${((result.avgConfidence || 0) * 100).toFixed(1)}%`,
-                `Cost Savings: ${costSavings}% vs all-opus`,
-                `Circuit Breaker Trips: ${result.circuitBreakerTrips || 0}`,
-            ].join('\n'), 'Model Routing Statistics');
-            if (dist && Object.keys(dist).length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Model Distribution'));
-                output.printTable({
-                    columns: [
-                        { key: 'model', header: 'Model', width: 10 },
-                        { key: 'count', header: 'Tasks', width: 8, align: 'right' },
-                        { key: 'percentage', header: '%', width: 8, align: 'right' },
-                        { key: 'costMultiplier', header: 'Cost', width: 8, align: 'right' },
-                    ],
-                    data: Object.entries(dist)
-                        .filter(([model]) => model !== 'inherit')
-                        .map(([model, count]) => ({
-                        model: model.toUpperCase(),
-                        count,
-                        percentage: totalTasks > 0 ? `${((count / totalTasks) * 100).toFixed(1)}%` : '0%',
-                        costMultiplier: `${costMultipliers[model] || 1}x`,
-                    })),
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(`Failed to get stats: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Teammate Idle command - Agent Teams integration
-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
-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
-const notifyCommand = {
-    name: 'notify',
-    description: 'Send a notification message (logged to session)',
-    options: [
-        { name: 'message', short: 'm', type: 'string', description: 'Notification message', required: true },
-        { name: 'level', short: 'l', type: 'string', description: 'Level: info, warn, error', default: 'info' },
-        { name: 'channel', short: 'c', type: 'string', description: 'Notification channel', default: 'console' },
-    ],
-    examples: [
-        { command: 'monomind hooks notify -m "Build complete"', description: 'Send info notification' },
-        { command: 'monomind hooks notify -m "Test failed" -l error', description: 'Send error notification' },
-    ],
-    action: async (ctx) => {
-        const message = ctx.args[0] || ctx.flags.message;
-        const level = ctx.flags.level || 'info';
-        if (!message) {
-            output.printError('Message is required: --message "your message"');
-            return { success: false, exitCode: 1 };
-        }
-        const timestamp = new Date().toISOString();
-        if (level === 'error') {
-            output.printError(`[${timestamp}] ${message}`);
-        }
-        else if (level === 'warn') {
-            output.writeln(output.warning(`[${timestamp}] ${message}`));
-        }
-        else {
-            output.printInfo(`[${timestamp}] ${message}`);
-        }
-        // Store notification in memory if available
-        try {
-            const { storeEntry } = await import('../memory/memory-initializer.js');
-            await storeEntry({ key: `notify-${Date.now()}`, value: `[${level}] ${message}`, namespace: 'notifications' });
-        }
-        catch { /* memory not available */ }
-        return { success: true, data: { timestamp, level, message } };
-    }
-};
 // Main hooks command
 export const hooksCommand = {
     name: 'hooks',