@monoes/monomindcli 1.14.7 → 1.15.1

package/dist/src/commands/hooks-workers.js

@@ -0,0 +1,782 @@
+/**
+ * Hooks Worker Commands
+ * Background worker management (12 workers) + Intelligence command
+ * Extracted from hooks.ts to reduce file size.
+ */
+import { output } from '../output.js';
+import { confirm } from '../prompt.js';
+import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { statSync, readFileSync } from 'node:fs';
+import { formatIntelligenceStatus, formatWorkerStatus } from './hooks-formatting.js';
+// =============================================================================
+// Intelligence subcommand (JS pattern/trajectory logging)
+// =============================================================================
+export 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
+                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 };
+        }
+    }
+};
+// =============================================================================
+// 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(output.dim(`Total: ${result.summary.total} | Running: ${result.summary.running} | Completed: ${result.summary.completed} | Failed: ${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 };
+        }
+    }
+};
+// Worker parent command
+export 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 };
+    }
+};
+//# sourceMappingURL=hooks-workers.js.map