@claude-flow/cli 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/commands/hooks.ts

@@ -1,2603 +0,0 @@
-/**
- * V3 CLI Hooks Command
- * Self-learning hooks system for intelligent workflow automation
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { select, confirm, input } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-
-// 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: Command = {
-  name: 'pre-edit',
-  description: 'Get context and agent suggestions before editing a file',
-  options: [
-    {
-      name: 'file',
-      short: 'f',
-      description: 'File path to edit',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'operation',
-      short: 'o',
-      description: 'Type of edit operation (create, update, delete, refactor)',
-      type: 'string',
-      default: 'update'
-    },
-    {
-      name: 'context',
-      short: 'c',
-      description: 'Additional context about the edit',
-      type: 'string'
-    }
-  ],
-  examples: [
-    { command: 'claude-flow hooks pre-edit -f src/utils.ts', description: 'Get context before editing' },
-    { command: 'claude-flow hooks pre-edit -f src/api.ts -o refactor', description: 'Pre-edit with operation type' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const filePath = ctx.args[0] || ctx.flags.file as string;
-    const operation = ctx.flags.operation as string || 'update';
-
-    if (!filePath) {
-      output.printError('File path is required. Use --file or -f flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Analyzing context for: ${output.highlight(filePath)}`);
-
-    try {
-      // Call MCP tool for pre-edit hook
-      const result = await callMCPTool<{
-        filePath: string;
-        operation: string;
-        context: {
-          fileExists: boolean;
-          fileType: string;
-          relatedFiles: string[];
-          suggestedAgents: string[];
-          patterns: Array<{ pattern: string; confidence: number }>;
-          risks: string[];
-        };
-        recommendations: string[];
-      }>('hooks/pre-edit', {
-        filePath,
-        operation,
-        context: ctx.flags.context,
-        includePatterns: true,
-        includeRisks: true,
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      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) {
-        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)}%` }
-          ],
-          data: result.context.patterns
-        });
-      }
-
-      if (result.context.risks.length > 0) {
-        output.writeln();
-        output.writeln(output.bold(output.error('Potential Risks')));
-        output.printList(result.context.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}`)));
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Pre-edit hook failed: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Post-edit subcommand
-const postEditCommand: Command = {
-  name: 'post-edit',
-  description: 'Record editing outcome for learning',
-  options: [
-    {
-      name: 'file',
-      short: 'f',
-      description: 'File path that was edited',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'success',
-      short: 's',
-      description: 'Whether the edit was successful',
-      type: 'boolean',
-      required: true
-    },
-    {
-      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: 'claude-flow hooks post-edit -f src/utils.ts --success true', description: 'Record successful edit' },
-    { command: 'claude-flow hooks post-edit -f src/api.ts --success false -o "Type error"', description: 'Record failed edit' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const filePath = ctx.args[0] || ctx.flags.file as string;
-    const success = ctx.flags.success as boolean;
-
-    if (!filePath) {
-      output.printError('File path is required. Use --file or -f flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (success === undefined) {
-      output.printError('Success flag is required. Use --success true/false.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Recording outcome for: ${output.highlight(filePath)}`);
-
-    try {
-      // Parse metrics if provided
-      const metrics: Record<string, number> = {};
-      if (ctx.flags.metrics) {
-        const metricsStr = ctx.flags.metrics as string;
-        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<{
-        filePath: string;
-        success: boolean;
-        recorded: boolean;
-        patternId?: string;
-        learningUpdates: {
-          patternsUpdated: number;
-          confidenceAdjusted: number;
-          newPatterns: number;
-        };
-      }>('hooks/post-edit', {
-        filePath,
-        success,
-        outcome: ctx.flags.outcome,
-        metrics,
-        timestamp: Date.now(),
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.printSuccess(`Outcome recorded for ${filePath}`);
-
-      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 }
-          ]
-        });
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Post-edit hook failed: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Pre-command subcommand
-const preCommandCommand: Command = {
-  name: 'pre-command',
-  description: 'Assess risk before executing a command',
-  options: [
-    {
-      name: 'command',
-      short: 'c',
-      description: 'Command to execute',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'dry-run',
-      short: 'd',
-      description: 'Only analyze, do not execute',
-      type: 'boolean',
-      default: true
-    }
-  ],
-  examples: [
-    { command: 'claude-flow hooks pre-command -c "rm -rf dist"', description: 'Assess command risk' },
-    { command: 'claude-flow hooks pre-command -c "npm install lodash"', description: 'Check package install' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const command = ctx.args[0] || ctx.flags.command as string;
-
-    if (!command) {
-      output.printError('Command is required. Use --command or -c flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Analyzing command: ${output.highlight(command)}`);
-
-    try {
-      // Call MCP tool for pre-command hook
-      const result = await callMCPTool<{
-        command: string;
-        riskLevel: 'low' | 'medium' | 'high' | 'critical';
-        risks: Array<{ type: string; severity: string; description: string }>;
-        recommendations: string[];
-        safeAlternatives?: string[];
-        shouldProceed: boolean;
-      }>('hooks/pre-command', {
-        command,
-        includeAlternatives: true,
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-
-      // Risk level indicator
-      let riskIndicator: string;
-      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.writeln();
-        output.writeln(output.bold('Recommendations'));
-        output.printList(result.recommendations);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Pre-command hook failed: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Post-command subcommand
-const postCommandCommand: Command = {
-  name: 'post-command',
-  description: 'Record command execution outcome',
-  options: [
-    {
-      name: 'command',
-      short: 'c',
-      description: 'Command that was executed',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'success',
-      short: 's',
-      description: 'Whether the command succeeded',
-      type: 'boolean',
-      required: true
-    },
-    {
-      name: 'exit-code',
-      short: 'e',
-      description: 'Command exit code',
-      type: 'number',
-      default: 0
-    },
-    {
-      name: 'duration',
-      short: 'd',
-      description: 'Execution duration in milliseconds',
-      type: 'number'
-    }
-  ],
-  examples: [
-    { command: 'claude-flow hooks post-command -c "npm test" --success true', description: 'Record successful test run' },
-    { command: 'claude-flow hooks post-command -c "npm build" --success false -e 1', description: 'Record failed build' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const command = ctx.args[0] || ctx.flags.command as string;
-    const success = ctx.flags.success as boolean;
-
-    if (!command) {
-      output.printError('Command is required. Use --command or -c flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (success === undefined) {
-      output.printError('Success flag is required. Use --success true/false.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Recording command outcome: ${output.highlight(command)}`);
-
-    try {
-      // Call MCP tool for post-command hook
-      const result = await callMCPTool<{
-        command: string;
-        success: boolean;
-        recorded: boolean;
-        learningUpdates: {
-          commandPatternsUpdated: number;
-          riskAssessmentUpdated: boolean;
-        };
-      }>('hooks/post-command', {
-        command,
-        success,
-        exitCode: ctx.flags.exitCode || 0,
-        duration: ctx.flags.duration,
-        timestamp: Date.now(),
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.printSuccess('Command outcome recorded');
-
-      if (result.learningUpdates) {
-        output.writeln();
-        output.writeln(output.dim(`Patterns updated: ${result.learningUpdates.commandPatternsUpdated}`));
-        output.writeln(output.dim(`Risk assessment: ${result.learningUpdates.riskAssessmentUpdated ? 'Updated' : 'No change'}`));
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Post-command hook failed: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Route subcommand
-const routeCommand: Command = {
-  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: 'claude-flow hooks route -t "Fix authentication bug"', description: 'Route task to optimal agent' },
-    { command: 'claude-flow hooks route -t "Optimize database queries" -k 5', description: 'Get top 5 suggestions' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const task = ctx.args[0] || ctx.flags.task as string;
-    const topK = ctx.flags.topK as number || 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<{
-        task: string;
-        primaryAgent: {
-          type: string;
-          confidence: number;
-          reason: string;
-        };
-        alternativeAgents: Array<{
-          type: string;
-          confidence: number;
-          reason: string;
-        }>;
-        estimatedMetrics: {
-          successProbability: number;
-          estimatedDuration: string;
-          complexity: 'low' | 'medium' | 'high';
-        };
-      }>('hooks/route', {
-        task,
-        context: ctx.flags.context,
-        topK,
-        includeEstimates: true,
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      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: Command = {
-  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: 'claude-flow hooks explain -t "Fix authentication bug"', description: 'Explain routing decision' },
-    { command: 'claude-flow hooks explain -t "Optimize queries" -a coder --verbose', description: 'Verbose explanation for specific agent' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const task = ctx.args[0] || ctx.flags.task as string;
-
-    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<{
-        task: string;
-        explanation: string;
-        factors: Array<{
-          factor: string;
-          weight: number;
-          value: number;
-          impact: string;
-        }>;
-        patterns: Array<{
-          pattern: string;
-          matchScore: number;
-          examples: string[];
-        }>;
-        decision: {
-          agent: string;
-          confidence: number;
-          reasoning: string[];
-        };
-      }>('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: Command = {
-  name: 'pretrain',
-  description: 'Bootstrap intelligence from repository (4-step pipeline)',
-  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
-    }
-  ],
-  examples: [
-    { command: 'claude-flow hooks pretrain', description: 'Pretrain from current repository' },
-    { command: 'claude-flow hooks pretrain -p ../my-project --depth deep', description: 'Deep analysis of specific project' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const path = ctx.flags.path as string || '.';
-    const depth = ctx.flags.depth as string || 'medium';
-
-    output.writeln();
-    output.writeln(output.bold('Pretraining Intelligence (4-Step Pipeline)'));
-    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' }
-    ];
-
-    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<{
-        path: string;
-        depth: string;
-        stats: {
-          filesAnalyzed: number;
-          patternsExtracted: number;
-          strategiesLearned: number;
-          trajectoriesEvaluated: number;
-          contradictionsResolved: number;
-        };
-        duration: number;
-      }>('hooks/pretrain', {
-        path,
-        depth,
-        skipCache: ctx.flags.skipCache || false,
-      });
-
-      spinner.succeed('Pretraining completed');
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'metric', header: 'Metric', width: 30 },
-          { key: 'value', header: 'Value', width: 15, align: 'right' }
-        ],
-        data: [
-          { 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 },
-          { metric: 'Duration', value: `${(result.duration / 1000).toFixed(1)}s` }
-        ]
-      });
-
-      output.writeln();
-      output.printSuccess('Repository intelligence bootstrapped successfully');
-      output.writeln(output.dim('  Next step: Run "claude-flow 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: Command = {
-  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 (v3-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: 'claude-flow hooks build-agents', description: 'Build all agent configs' },
-    { command: 'claude-flow hooks build-agents --focus security -o ./config/agents', description: 'Build security-focused configs' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const output_dir = ctx.flags.output as string || './agents';
-    const focus = ctx.flags.focus as string || 'all';
-    const configFormat = ctx.flags.configFormat as string || '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<{
-        outputDir: string;
-        focus: string;
-        agents: Array<{
-          type: string;
-          configFile: string;
-          capabilities: string[];
-          optimizations: string[];
-        }>;
-        stats: {
-          configsGenerated: number;
-          patternsApplied: number;
-          optimizationsIncluded: number;
-        };
-      }>('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: Command = {
-  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: 'v3-dashboard',
-      description: 'Show V3 performance dashboard',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'category',
-      short: 'c',
-      description: 'Metric category (patterns, agents, commands, performance)',
-      type: 'string'
-    }
-  ],
-  examples: [
-    { command: 'claude-flow hooks metrics', description: 'View 24h metrics' },
-    { command: 'claude-flow hooks metrics --period 7d --v3-dashboard', description: 'V3 metrics for 7 days' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const period = ctx.flags.period as string || '24h';
-    const v3Dashboard = ctx.flags.v3Dashboard as boolean;
-
-    output.writeln();
-    output.writeln(output.bold(`Learning Metrics Dashboard (${period})`));
-    output.writeln();
-
-    try {
-      // Call MCP tool for metrics
-      const result = await callMCPTool<{
-        period: string;
-        patterns: {
-          total: number;
-          successful: number;
-          failed: number;
-          avgConfidence: number;
-        };
-        agents: {
-          routingAccuracy: number;
-          totalRoutes: number;
-          topAgent: string;
-        };
-        commands: {
-          totalExecuted: number;
-          successRate: number;
-          avgRiskScore: number;
-        };
-        performance: {
-          flashAttention: string;
-          memoryReduction: string;
-          searchImprovement: string;
-          tokenReduction: string;
-        };
-      }>('hooks/metrics', {
-        period,
-        includeV3: v3Dashboard,
-        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 (v3Dashboard && result.performance) {
-        output.writeln();
-        output.writeln(output.bold('🚀 V3 Performance Gains'));
-        output.printList([
-          `Flash Attention: ${output.success(result.performance.flashAttention)}`,
-          `Memory Reduction: ${output.success(result.performance.memoryReduction)}`,
-          `Search Improvement: ${output.success(result.performance.searchImprovement)}`,
-          `Token Reduction: ${output.success(result.performance.tokenReduction)}`
-        ]);
-      }
-
-      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 };
-    }
-  }
-};
-
-// Transfer subcommand
-const transferCommand: Command = {
-  name: 'transfer',
-  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: 'claude-flow hooks transfer -s ../old-project', description: 'Transfer all patterns' },
-    { command: 'claude-flow hooks transfer -s ../prod --filter security -m 0.9', description: 'Transfer high-confidence security patterns' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const sourcePath = ctx.args[0] || ctx.flags.source as string;
-    const minConfidence = ctx.flags.minConfidence as number || 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<{
-        sourcePath: string;
-        transferred: {
-          total: number;
-          byType: Record<string, number>;
-        };
-        skipped: {
-          lowConfidence: number;
-          duplicates: number;
-          conflicts: number;
-        };
-        stats: {
-          avgConfidence: number;
-          avgAge: string;
-        };
-      }>('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 };
-    }
-  }
-};
-
-// List subcommand
-const listCommand: Command = {
-  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: CommandContext): Promise<CommandResult> => {
-    try {
-      // Call MCP tool for list
-      const result = await callMCPTool<{
-        hooks: Array<{
-          name: string;
-          type: string;
-          enabled: boolean;
-          priority: number;
-          executionCount: number;
-          lastExecuted?: string;
-        }>;
-        total: number;
-      }>('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: Command = {
-  name: 'pre-task',
-  description: 'Record task start and get agent suggestions',
-  options: [
-    {
-      name: 'task-id',
-      short: 'i',
-      description: 'Unique task identifier',
-      type: 'string',
-      required: true
-    },
-    {
-      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: 'claude-flow hooks pre-task -i task-123 -d "Fix auth bug"', description: 'Record task start' },
-    { command: 'claude-flow hooks pre-task -i task-456 -d "Implement feature" --auto-spawn', description: 'With auto-spawn' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const taskId = ctx.flags.taskId as string;
-    const description = ctx.args[0] || ctx.flags.description as string;
-
-    if (!taskId || !description) {
-      output.printError('Task ID and description are required.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Starting task: ${output.highlight(taskId)}`);
-
-    try {
-      const result = await callMCPTool<{
-        taskId: string;
-        description: string;
-        suggestedAgents: Array<{
-          type: string;
-          confidence: number;
-          reason: string;
-        }>;
-        complexity: 'low' | 'medium' | 'high';
-        estimatedDuration: string;
-        risks: string[];
-        recommendations: string[];
-      }>('hooks/pre-task', {
-        taskId,
-        description,
-        autoSpawn: ctx.flags.autoSpawn || 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);
-      }
-
-      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: Command = {
-  name: 'post-task',
-  description: 'Record task completion for learning',
-  options: [
-    {
-      name: 'task-id',
-      short: 'i',
-      description: 'Unique task identifier',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'success',
-      short: 's',
-      description: 'Whether the task succeeded',
-      type: 'boolean',
-      required: true
-    },
-    {
-      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: 'claude-flow hooks post-task -i task-123 --success true', description: 'Record successful completion' },
-    { command: 'claude-flow hooks post-task -i task-456 --success false -q 0.3', description: 'Record failed task' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const taskId = ctx.flags.taskId as string;
-    const success = ctx.flags.success as boolean;
-
-    if (!taskId) {
-      output.printError('Task ID is required. Use --task-id or -i flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (success === undefined) {
-      output.printError('Success flag is required. Use --success true/false.');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Recording outcome for task: ${output.highlight(taskId)}`);
-
-    try {
-      const result = await callMCPTool<{
-        taskId: string;
-        success: boolean;
-        duration: number;
-        learningUpdates: {
-          patternsUpdated: number;
-          newPatterns: number;
-          trajectoryId: string;
-        };
-      }>('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: Command = {
-  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: 'claude-flow hooks session-end', description: 'End and save session' },
-    { command: 'claude-flow hooks session-end --save-state false', description: 'End without saving' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.printInfo('Ending session...');
-
-    try {
-      const result = await callMCPTool<{
-        sessionId: string;
-        duration: number;
-        statePath?: string;
-        summary: {
-          tasksExecuted: number;
-          tasksSucceeded: number;
-          tasksFailed: number;
-          commandsExecuted: number;
-          filesModified: number;
-          agentsSpawned: number;
-        };
-      }>('hooks/session-end', {
-        saveState: ctx.flags.saveState ?? 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: Command = {
-  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: 'claude-flow hooks session-restore', description: 'Restore latest session' },
-    { command: 'claude-flow hooks session-restore -i session-12345', description: 'Restore specific session' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const sessionId = ctx.args[0] || ctx.flags.sessionId as string || 'latest';
-
-    output.printInfo(`Restoring session: ${output.highlight(sessionId)}`);
-
-    try {
-      const result = await callMCPTool<{
-        sessionId: string;
-        originalSessionId: string;
-        restoredState: {
-          tasksRestored: number;
-          agentsRestored: number;
-          memoryRestored: number;
-        };
-        warnings?: string[];
-      }>('hooks/session-restore', {
-        sessionId,
-        restoreAgents: ctx.flags.restoreAgents ?? true,
-        restoreTasks: ctx.flags.restoreTasks ?? 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 (SONA, MoE, HNSW)
-const intelligenceCommand: Command = {
-  name: 'intelligence',
-  description: 'RuVector intelligence system (SONA, MoE, HNSW 150x faster)',
-  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: 'claude-flow hooks intelligence --status', description: 'Show intelligence status' },
-    { command: 'claude-flow hooks intelligence -m real-time', description: 'Enable real-time mode' },
-    { command: 'claude-flow hooks intelligence --train', description: 'Force training cycle' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const mode = ctx.flags.mode as string || 'balanced';
-    const showStatus = ctx.flags.status as boolean;
-    const forceTraining = ctx.flags.train as boolean;
-    const reset = ctx.flags.reset as boolean;
-    const enableSona = ctx.flags.enableSona as boolean ?? true;
-    const enableMoe = ctx.flags.enableMoe as boolean ?? true;
-    const enableHnsw = ctx.flags.enableHnsw as boolean ?? true;
-    const embeddingProvider = ctx.flags.embeddingProvider as string || 'transformers';
-
-    output.writeln();
-    output.writeln(output.bold('RuVector 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();
-
-      // Call MCP tool for intelligence
-      const result = await callMCPTool<{
-        mode: string;
-        status: 'active' | 'idle' | 'training' | 'disabled';
-        components: {
-          sona: {
-            enabled: boolean;
-            status: string;
-            learningTimeMs: number;
-            adaptationTimeMs: number;
-            trajectoriesRecorded: number;
-            patternsLearned: number;
-            avgQuality: number;
-          };
-          moe: {
-            enabled: boolean;
-            status: string;
-            expertsActive: number;
-            routingAccuracy: number;
-            loadBalance: number;
-          };
-          hnsw: {
-            enabled: boolean;
-            status: string;
-            indexSize: number;
-            searchSpeedup: string;
-            memoryUsage: string;
-            dimension: number;
-          };
-          embeddings: {
-            provider: string;
-            model: string;
-            dimension: number;
-            cacheHitRate: number;
-          };
-        };
-        performance: {
-          flashAttention: string;
-          memoryReduction: string;
-          searchImprovement: string;
-          tokenReduction: string;
-          sweBenchScore: string;
-        };
-        lastTrainingMs?: number;
-      }>('hooks/intelligence', {
-        mode,
-        enableSona,
-        enableMoe,
-        enableHnsw,
-        embeddingProvider,
-        forceTraining,
-        showStatus,
-      });
-
-      if (forceTraining) {
-        spinner.setText('Running training cycle...');
-        await new Promise(resolve => setTimeout(resolve, 500));
-        spinner.succeed('Training cycle completed');
-      } else {
-        spinner.succeed('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 ? `${result.lastTrainingMs.toFixed(2)}ms` : 'Never'}`
-        ].join('\n'),
-        'Intelligence Status'
-      );
-
-      // SONA Component
-      output.writeln();
-      output.writeln(output.bold('🧠 SONA (Sub-0.05ms Learning)'));
-      if (result.components.sona.enabled) {
-        output.printTable({
-          columns: [
-            { key: 'metric', header: 'Metric', width: 25 },
-            { key: 'value', header: 'Value', width: 20, align: 'right' }
-          ],
-          data: [
-            { metric: 'Status', value: formatIntelligenceStatus(result.components.sona.status) },
-            { metric: 'Learning Time', value: `${result.components.sona.learningTimeMs.toFixed(3)}ms` },
-            { metric: 'Adaptation Time', value: `${result.components.sona.adaptationTimeMs.toFixed(3)}ms` },
-            { metric: 'Trajectories', value: result.components.sona.trajectoriesRecorded },
-            { metric: 'Patterns Learned', value: result.components.sona.patternsLearned },
-            { metric: 'Avg Quality', value: `${(result.components.sona.avgQuality * 100).toFixed(1)}%` }
-          ]
-        });
-      } else {
-        output.writeln(output.dim('  Disabled'));
-      }
-
-      // MoE Component
-      output.writeln();
-      output.writeln(output.bold('🔀 Mixture of Experts (MoE)'));
-      if (result.components.moe.enabled) {
-        output.printTable({
-          columns: [
-            { key: 'metric', header: 'Metric', width: 25 },
-            { key: 'value', header: 'Value', width: 20, align: 'right' }
-          ],
-          data: [
-            { metric: 'Status', value: formatIntelligenceStatus(result.components.moe.status) },
-            { metric: 'Active Experts', value: result.components.moe.expertsActive },
-            { metric: 'Routing Accuracy', value: `${(result.components.moe.routingAccuracy * 100).toFixed(1)}%` },
-            { metric: 'Load Balance', value: `${(result.components.moe.loadBalance * 100).toFixed(1)}%` }
-          ]
-        });
-      } else {
-        output.writeln(output.dim('  Disabled'));
-      }
-
-      // HNSW Component
-      output.writeln();
-      output.writeln(output.bold('🔍 HNSW (150x Faster Search)'));
-      if (result.components.hnsw.enabled) {
-        output.printTable({
-          columns: [
-            { key: 'metric', header: 'Metric', width: 25 },
-            { key: 'value', header: 'Value', width: 20, align: 'right' }
-          ],
-          data: [
-            { metric: 'Status', value: formatIntelligenceStatus(result.components.hnsw.status) },
-            { metric: 'Index Size', value: result.components.hnsw.indexSize.toLocaleString() },
-            { metric: 'Search Speedup', value: output.success(result.components.hnsw.searchSpeedup) },
-            { metric: 'Memory Usage', value: result.components.hnsw.memoryUsage },
-            { metric: 'Dimension', value: result.components.hnsw.dimension }
-          ]
-        });
-      } else {
-        output.writeln(output.dim('  Disabled'));
-      }
-
-      // Embeddings
-      output.writeln();
-      output.writeln(output.bold('📦 Embeddings (ONNX)'));
-      output.printTable({
-        columns: [
-          { key: 'metric', header: 'Metric', width: 25 },
-          { key: 'value', header: 'Value', width: 20, align: 'right' }
-        ],
-        data: [
-          { metric: 'Provider', value: result.components.embeddings.provider },
-          { metric: 'Model', value: result.components.embeddings.model },
-          { metric: 'Dimension', value: result.components.embeddings.dimension },
-          { metric: 'Cache Hit Rate', value: `${(result.components.embeddings.cacheHitRate * 100).toFixed(1)}%` }
-        ]
-      });
-
-      // V3 Performance
-      output.writeln();
-      output.writeln(output.bold('🚀 V3 Performance Gains'));
-      output.printList([
-        `Flash Attention: ${output.success(result.performance.flashAttention)}`,
-        `Memory Reduction: ${output.success(result.performance.memoryReduction)}`,
-        `Search Improvement: ${output.success(result.performance.searchImprovement)}`,
-        `Token Reduction: ${output.success(result.performance.tokenReduction)}`,
-        `SWE-Bench Score: ${output.success(result.performance.sweBenchScore)}`
-      ]);
-
-      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: string): string {
-  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: Command = {
-  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: 'claude-flow hooks worker list', description: 'List all workers' },
-    { command: 'claude-flow hooks worker list --active', description: 'Show active instances' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const spinner = output.createSpinner({ text: 'Loading workers...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const result = await callMCPTool<{
-        workers: Array<{
-          trigger: string;
-          description: string;
-          priority: string;
-          estimatedDuration: string;
-          capabilities: string[];
-          patterns: number;
-        }>;
-        total: number;
-        active: {
-          instances: Array<{
-            id: string;
-            trigger: string;
-            status: string;
-            progress: number;
-            phase: string;
-          }>;
-          count: number;
-          byStatus: Record<string, number>;
-        };
-        performanceTargets: Record<string, string | number>;
-      }>('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: Command = {
-  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: 'claude-flow hooks worker dispatch -t optimize -c src/', description: 'Dispatch optimize worker' },
-    { command: 'claude-flow hooks worker dispatch -t audit -p critical', description: 'Security audit with critical priority' },
-    { command: 'claude-flow hooks worker dispatch -t testgaps --sync', description: 'Test coverage analysis (sync)' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const trigger = ctx.flags['trigger'] as string;
-    const context = ctx.flags['context'] as string || 'default';
-    const priority = ctx.flags['priority'] as string;
-    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<{
-        success: boolean;
-        workerId: string;
-        trigger: string;
-        context: string;
-        priority: string;
-        config: {
-          description: string;
-          estimatedDuration: string;
-          capabilities: string[];
-        };
-        status: string;
-        error?: string;
-      }>('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: claude-flow 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: Command = {
-  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: 'claude-flow hooks worker status', description: 'Show running workers' },
-    { command: 'claude-flow hooks worker status --id worker_audit_1', description: 'Check specific worker' },
-    { command: 'claude-flow hooks worker status --all', description: 'Include completed workers' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const workerId = ctx.flags['id'] as string;
-    const includeCompleted = ctx.flags['all'] as boolean;
-
-    const spinner = output.createSpinner({ text: 'Checking worker status...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const result = await callMCPTool<{
-        success: boolean;
-        worker?: {
-          id: string;
-          trigger: string;
-          context: string;
-          status: string;
-          progress: number;
-          phase: string;
-          duration: number;
-        };
-        workers?: Array<{
-          id: string;
-          trigger: string;
-          status: string;
-          progress: number;
-          phase: string;
-          duration: number;
-        }>;
-        summary?: {
-          total: number;
-          running: number;
-          completed: number;
-          failed: number;
-        };
-        error?: string;
-      }>('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: Command = {
-  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: 'claude-flow hooks worker detect -p "optimize performance"', description: 'Detect triggers in prompt' },
-    { command: 'claude-flow hooks worker detect -p "security audit" --auto-dispatch', description: 'Detect and dispatch' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const prompt = ctx.flags['prompt'] as string;
-    const autoDispatch = ctx.flags['auto-dispatch'] as boolean;
-    const minConfidence = parseFloat(ctx.flags['min-confidence'] as string || '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<{
-        prompt: string;
-        detection: {
-          detected: boolean;
-          triggers: string[];
-          confidence: number;
-          context: string;
-        };
-        triggersFound: number;
-        triggerDetails?: Array<{
-          trigger: string;
-          description: string;
-          priority: string;
-        }>;
-        autoDispatched?: boolean;
-        workerIds?: string[];
-      }>('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: Command = {
-  name: 'cancel',
-  description: 'Cancel a running worker',
-  options: [
-    { name: 'id', type: 'string', description: 'Worker ID to cancel', required: true },
-  ],
-  examples: [
-    { command: 'claude-flow hooks worker cancel --id worker_audit_1', description: 'Cancel specific worker' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const workerId = ctx.flags['id'] as string;
-
-    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<{
-        success: boolean;
-        workerId: string;
-        cancelled: boolean;
-        error?: string;
-      }>('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: string): string {
-  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;
-  }
-}
-
-// Worker parent command
-const workerCommand: Command = {
-  name: 'worker',
-  description: 'Background worker management (12 workers for analysis/optimization)',
-  subcommands: [
-    workerListCommand,
-    workerDispatchCommand,
-    workerStatusCommand,
-    workerDetectCommand,
-    workerCancelCommand,
-  ],
-  options: [],
-  examples: [
-    { command: 'claude-flow hooks worker list', description: 'List all workers' },
-    { command: 'claude-flow hooks worker dispatch -t optimize', description: 'Dispatch optimizer' },
-    { command: 'claude-flow hooks worker detect -p "test coverage"', description: 'Detect from prompt' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    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 "claude-flow hooks worker <subcommand> --help" for details');
-
-    return { success: true };
-  }
-};
-
-// Main hooks command
-export const hooksCommand: Command = {
-  name: 'hooks',
-  description: 'Self-learning hooks system for intelligent workflow automation',
-  subcommands: [
-    preEditCommand,
-    postEditCommand,
-    preCommandCommand,
-    postCommandCommand,
-    preTaskCommand,
-    postTaskCommand,
-    sessionEndCommand,
-    sessionRestoreCommand,
-    routeCommand,
-    explainCommand,
-    pretrainCommand,
-    buildAgentsCommand,
-    metricsCommand,
-    transferCommand,
-    listCommand,
-    intelligenceCommand,
-    workerCommand,
-  ],
-  options: [],
-  examples: [
-    { command: 'claude-flow hooks pre-edit -f src/utils.ts', description: 'Get context before editing' },
-    { command: 'claude-flow hooks route -t "Fix authentication bug"', description: 'Route task to optimal agent' },
-    { command: 'claude-flow hooks pretrain', description: 'Bootstrap intelligence from repository' },
-    { command: 'claude-flow hooks metrics --v3-dashboard', description: 'View V3 performance metrics' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Self-Learning Hooks System'));
-    output.writeln();
-    output.writeln('Intelligent workflow automation with pattern learning and adaptive routing');
-    output.writeln();
-    output.writeln('Usage: claude-flow hooks <subcommand> [options]');
-    output.writeln();
-    output.writeln('Subcommands:');
-    output.printList([
-      `${output.highlight('pre-edit')}        - Get context before editing files`,
-      `${output.highlight('post-edit')}       - Record editing outcomes for learning`,
-      `${output.highlight('pre-command')}     - Assess risk before executing commands`,
-      `${output.highlight('post-command')}    - Record command execution outcomes`,
-      `${output.highlight('pre-task')}        - Record task start and get agent suggestions`,
-      `${output.highlight('post-task')}       - Record task completion for learning`,
-      `${output.highlight('session-end')}     - End current session and persist state`,
-      `${output.highlight('session-restore')} - Restore a previous session`,
-      `${output.highlight('route')}           - Route tasks to optimal agents`,
-      `${output.highlight('explain')}         - Explain routing decisions`,
-      `${output.highlight('pretrain')}        - Bootstrap intelligence from repository`,
-      `${output.highlight('build-agents')}    - Generate optimized agent configs`,
-      `${output.highlight('metrics')}         - View learning metrics dashboard`,
-      `${output.highlight('transfer')}        - Transfer patterns from another project`,
-      `${output.highlight('list')}            - List all registered hooks`,
-      `${output.highlight('worker')}          - Background worker management (12 workers)`
-    ]);
-    output.writeln();
-    output.writeln('Run "claude-flow hooks <subcommand> --help" for subcommand help');
-    output.writeln();
-    output.writeln(output.bold('V3 Features:'));
-    output.printList([
-      '🧠 ReasoningBank adaptive learning',
-      '⚡ Flash Attention (2.49x-7.47x speedup)',
-      '🔍 AgentDB integration (150x faster search)',
-      '📊 84.8% SWE-Bench solve rate',
-      '🎯 32.3% token reduction',
-      '🚀 2.8-4.4x speed improvement'
-    ]);
-
-    return { success: true };
-  }
-};
-
-export default hooksCommand;