claude-flow 3.10.1 → 3.10.4

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/testing/src/v2-compat/compatibility-validator.ts

@@ -1,1072 +0,0 @@
-/**
- * V2 Compatibility Validator
- *
- * Validates that V3 implementation maintains backward compatibility with V2 capabilities.
- * Tests CLI commands, MCP tools, hooks, and API interfaces.
- *
- * @module v3/testing/v2-compat/compatibility-validator
- */
-
-import { vi } from 'vitest';
-
-/**
- * Validation result for a single check
- */
-export interface ValidationCheck {
-  name: string;
-  category: 'cli' | 'mcp' | 'hooks' | 'api';
-  passed: boolean;
-  message: string;
-  v2Behavior: string;
-  v3Behavior: string;
-  breaking: boolean;
-  migrationPath?: string;
-  details?: Record<string, unknown>;
-}
-
-/**
- * Validation result for a category
- */
-export interface ValidationResult {
-  category: 'cli' | 'mcp' | 'hooks' | 'api';
-  totalChecks: number;
-  passedChecks: number;
-  failedChecks: number;
-  breakingChanges: number;
-  checks: ValidationCheck[];
-  duration: number;
-}
-
-/**
- * Full validation report
- */
-export interface FullValidationReport {
-  timestamp: Date;
-  v2Version: string;
-  v3Version: string;
-  overallPassed: boolean;
-  totalChecks: number;
-  passedChecks: number;
-  failedChecks: number;
-  breakingChanges: number;
-  cli: ValidationResult;
-  mcp: ValidationResult;
-  hooks: ValidationResult;
-  api: ValidationResult;
-  summary: string;
-  recommendations: string[];
-  duration: number;
-}
-
-/**
- * V2 CLI command definition
- */
-export interface V2CLICommand {
-  name: string;
-  aliases: string[];
-  flags: string[];
-  description: string;
-  v3Equivalent?: string;
-  deprecated?: boolean;
-}
-
-/**
- * V2 MCP tool definition
- */
-export interface V2MCPTool {
-  name: string;
-  parameters: Record<string, { type: string; required: boolean }>;
-  returnType: string;
-  v3Equivalent?: string;
-  deprecated?: boolean;
-}
-
-/**
- * V2 hook definition
- */
-export interface V2Hook {
-  name: string;
-  trigger: string;
-  parameters: string[];
-  returnType: string;
-  v3Equivalent?: string;
-  deprecated?: boolean;
-}
-
-/**
- * V2 API interface definition
- */
-export interface V2APIInterface {
-  name: string;
-  methods: { name: string; signature: string }[];
-  v3Equivalent?: string;
-  deprecated?: boolean;
-}
-
-/**
- * V2 CLI Commands (25 total)
- */
-export const V2_CLI_COMMANDS: V2CLICommand[] = [
-  // Core commands
-  { name: 'init', aliases: ['i'], flags: ['--force', '--template'], description: 'Initialize claude-flow project', v3Equivalent: 'init' },
-  { name: 'start', aliases: ['s'], flags: ['--detached', '--port'], description: 'Start MCP server', v3Equivalent: 'start' },
-  { name: 'stop', aliases: [], flags: ['--force'], description: 'Stop MCP server', v3Equivalent: 'stop' },
-  { name: 'status', aliases: ['st'], flags: ['--json', '--verbose'], description: 'Show system status', v3Equivalent: 'status' },
-  { name: 'config', aliases: ['c'], flags: ['--get', '--set', '--list'], description: 'Manage configuration', v3Equivalent: 'config' },
-
-  // Agent commands
-  { name: 'agent spawn', aliases: ['a spawn'], flags: ['--type', '--id', '--config'], description: 'Spawn new agent', v3Equivalent: 'agent spawn' },
-  { name: 'agent list', aliases: ['a ls'], flags: ['--status', '--type'], description: 'List agents', v3Equivalent: 'agent list' },
-  { name: 'agent terminate', aliases: ['a kill'], flags: ['--force', '--all'], description: 'Terminate agent', v3Equivalent: 'agent terminate' },
-  { name: 'agent info', aliases: ['a info'], flags: ['--metrics'], description: 'Show agent info', v3Equivalent: 'agent status' },
-
-  // Swarm commands
-  { name: 'swarm init', aliases: ['sw init'], flags: ['--topology', '--max-agents'], description: 'Initialize swarm', v3Equivalent: 'swarm init' },
-  { name: 'swarm status', aliases: ['sw st'], flags: ['--detailed'], description: 'Show swarm status', v3Equivalent: 'swarm status' },
-  { name: 'swarm scale', aliases: ['sw scale'], flags: ['--up', '--down'], description: 'Scale swarm', v3Equivalent: 'swarm scale' },
-
-  // Memory commands
-  { name: 'memory list', aliases: ['mem ls'], flags: ['--type', '--limit'], description: 'List memories', v3Equivalent: 'memory list' },
-  { name: 'memory query', aliases: ['mem q'], flags: ['--search', '--type'], description: 'Query memory', v3Equivalent: 'memory search' },
-  { name: 'memory clear', aliases: ['mem clear'], flags: ['--force', '--type'], description: 'Clear memory', v3Equivalent: 'memory clear' },
-
-  // Hooks commands
-  { name: 'hooks pre-edit', aliases: [], flags: ['--file'], description: 'Pre-edit hook', v3Equivalent: 'hooks pre-edit' },
-  { name: 'hooks post-edit', aliases: [], flags: ['--file', '--success'], description: 'Post-edit hook', v3Equivalent: 'hooks post-edit' },
-  { name: 'hooks pre-command', aliases: [], flags: ['--command'], description: 'Pre-command hook', v3Equivalent: 'hooks pre-command' },
-  { name: 'hooks post-command', aliases: [], flags: ['--command', '--success'], description: 'Post-command hook', v3Equivalent: 'hooks post-command' },
-  { name: 'hooks route', aliases: [], flags: ['--task'], description: 'Route task', v3Equivalent: 'hooks route' },
-  { name: 'hooks pretrain', aliases: [], flags: [], description: 'Pretrain from repo', v3Equivalent: 'hooks pretrain' },
-  { name: 'hooks metrics', aliases: [], flags: ['--dashboard'], description: 'Show metrics', v3Equivalent: 'hooks metrics' },
-
-  // Deprecated but supported
-  { name: 'hive-mind init', aliases: [], flags: [], description: 'Initialize hive', v3Equivalent: 'swarm init', deprecated: true },
-  { name: 'neural init', aliases: [], flags: [], description: 'Initialize neural', v3Equivalent: 'hooks pretrain', deprecated: true },
-  { name: 'goal init', aliases: [], flags: [], description: 'Initialize goals', v3Equivalent: 'hooks pretrain', deprecated: true },
-];
-
-/**
- * V2 MCP Tools (65 total - showing key ones)
- */
-export const V2_MCP_TOOLS: V2MCPTool[] = [
-  // Agent tools
-  { name: 'dispatch_agent', parameters: { type: { type: 'string', required: true }, name: { type: 'string', required: false } }, returnType: 'AgentInfo', v3Equivalent: 'agent/spawn' },
-  { name: 'agents/spawn', parameters: { type: { type: 'string', required: true }, config: { type: 'object', required: false } }, returnType: 'AgentInfo', v3Equivalent: 'agent/spawn' },
-  { name: 'agents/list', parameters: { status: { type: 'string', required: false } }, returnType: 'AgentInfo[]', v3Equivalent: 'agent/list' },
-  { name: 'agents/terminate', parameters: { id: { type: 'string', required: true } }, returnType: 'boolean', v3Equivalent: 'agent/terminate' },
-  { name: 'agents/info', parameters: { id: { type: 'string', required: true } }, returnType: 'AgentInfo', v3Equivalent: 'agent/status' },
-  { name: 'agent/create', parameters: { type: { type: 'string', required: true } }, returnType: 'AgentInfo', v3Equivalent: 'agent/spawn' },
-
-  // Swarm tools
-  { name: 'swarm_status', parameters: {}, returnType: 'SwarmStatus', v3Equivalent: 'swarm/status' },
-  { name: 'swarm/get-status', parameters: {}, returnType: 'SwarmStatus', v3Equivalent: 'swarm/status' },
-  { name: 'swarm/get-comprehensive-status', parameters: {}, returnType: 'ComprehensiveStatus', v3Equivalent: 'swarm/status' },
-  { name: 'mcp__ruv-swarm__swarm_init', parameters: { topology: { type: 'string', required: false } }, returnType: 'SwarmInfo', v3Equivalent: 'swarm/init' },
-  { name: 'mcp__ruv-swarm__swarm_status', parameters: {}, returnType: 'SwarmStatus', v3Equivalent: 'swarm/status' },
-  { name: 'mcp__ruv-swarm__agent_spawn', parameters: { type: { type: 'string', required: true } }, returnType: 'AgentInfo', v3Equivalent: 'agent/spawn' },
-  { name: 'mcp__ruv-swarm__agent_list', parameters: {}, returnType: 'AgentInfo[]', v3Equivalent: 'agent/list' },
-  { name: 'mcp__ruv-swarm__agent_metrics', parameters: { id: { type: 'string', required: true } }, returnType: 'AgentMetrics', v3Equivalent: 'agent/status' },
-
-  // Memory tools
-  { name: 'memory/query', parameters: { search: { type: 'string', required: true } }, returnType: 'MemoryEntry[]', v3Equivalent: 'memory/search' },
-  { name: 'memory/store', parameters: { content: { type: 'string', required: true }, type: { type: 'string', required: false } }, returnType: 'MemoryEntry', v3Equivalent: 'memory/store' },
-  { name: 'memory/delete', parameters: { id: { type: 'string', required: true } }, returnType: 'boolean', v3Equivalent: 'memory/delete' },
-  { name: 'mcp__ruv-swarm__memory_usage', parameters: {}, returnType: 'MemoryStats', v3Equivalent: 'memory/list' },
-
-  // Config tools
-  { name: 'config/get', parameters: { key: { type: 'string', required: true } }, returnType: 'any', v3Equivalent: 'config/load' },
-  { name: 'config/update', parameters: { key: { type: 'string', required: true }, value: { type: 'any', required: true } }, returnType: 'boolean', v3Equivalent: 'config/save' },
-
-  // Task tools
-  { name: 'task/create', parameters: { description: { type: 'string', required: true } }, returnType: 'TaskInfo', v3Equivalent: 'task/create' },
-  { name: 'task/assign', parameters: { taskId: { type: 'string', required: true }, agentId: { type: 'string', required: true } }, returnType: 'boolean', v3Equivalent: 'task/assign' },
-  { name: 'task/status', parameters: { taskId: { type: 'string', required: true } }, returnType: 'TaskStatus', v3Equivalent: 'task/status' },
-  { name: 'task/complete', parameters: { taskId: { type: 'string', required: true }, result: { type: 'any', required: false } }, returnType: 'boolean', v3Equivalent: 'task/complete' },
-
-  // Neural/Learning tools
-  { name: 'mcp__ruv-swarm__neural_status', parameters: {}, returnType: 'NeuralStatus', v3Equivalent: 'hooks/metrics' },
-  { name: 'mcp__ruv-swarm__neural_train', parameters: { data: { type: 'object', required: true } }, returnType: 'TrainingResult', v3Equivalent: 'hooks/pretrain' },
-
-  // GitHub integration tools
-  { name: 'github/pr-create', parameters: { title: { type: 'string', required: true }, body: { type: 'string', required: false } }, returnType: 'PRInfo', v3Equivalent: 'github/pr-create' },
-  { name: 'github/pr-review', parameters: { prNumber: { type: 'number', required: true } }, returnType: 'ReviewInfo', v3Equivalent: 'github/pr-review' },
-  { name: 'github/issue-create', parameters: { title: { type: 'string', required: true } }, returnType: 'IssueInfo', v3Equivalent: 'github/issue-create' },
-
-  // Coordination tools
-  { name: 'coordinate/consensus', parameters: { proposal: { type: 'object', required: true } }, returnType: 'ConsensusResult', v3Equivalent: 'swarm/consensus' },
-  { name: 'coordinate/broadcast', parameters: { message: { type: 'object', required: true } }, returnType: 'BroadcastResult', v3Equivalent: 'swarm/broadcast' },
-];
-
-/**
- * V2 Hooks (42 total)
- */
-export const V2_HOOKS: V2Hook[] = [
-  // Edit hooks
-  { name: 'pre-edit', trigger: 'before:file:edit', parameters: ['filePath', 'content'], returnType: 'HookResult', v3Equivalent: 'pre-edit' },
-  { name: 'post-edit', trigger: 'after:file:edit', parameters: ['filePath', 'success', 'changes'], returnType: 'HookResult', v3Equivalent: 'post-edit' },
-  { name: 'pre-create', trigger: 'before:file:create', parameters: ['filePath'], returnType: 'HookResult', v3Equivalent: 'pre-edit' },
-  { name: 'post-create', trigger: 'after:file:create', parameters: ['filePath', 'success'], returnType: 'HookResult', v3Equivalent: 'post-edit' },
-
-  // Command hooks
-  { name: 'pre-command', trigger: 'before:command:execute', parameters: ['command', 'args'], returnType: 'HookResult', v3Equivalent: 'pre-command' },
-  { name: 'post-command', trigger: 'after:command:execute', parameters: ['command', 'success', 'output'], returnType: 'HookResult', v3Equivalent: 'post-command' },
-  { name: 'pre-bash', trigger: 'before:bash:execute', parameters: ['script'], returnType: 'HookResult', v3Equivalent: 'pre-command' },
-  { name: 'post-bash', trigger: 'after:bash:execute', parameters: ['script', 'exitCode'], returnType: 'HookResult', v3Equivalent: 'post-command' },
-
-  // Task hooks
-  { name: 'pre-task', trigger: 'before:task:start', parameters: ['task'], returnType: 'HookResult', v3Equivalent: 'pre-task' },
-  { name: 'post-task', trigger: 'after:task:complete', parameters: ['task', 'result'], returnType: 'HookResult', v3Equivalent: 'post-task' },
-  { name: 'task-assign', trigger: 'on:task:assign', parameters: ['task', 'agent'], returnType: 'HookResult', v3Equivalent: 'task-assign' },
-  { name: 'task-fail', trigger: 'on:task:fail', parameters: ['task', 'error'], returnType: 'HookResult', v3Equivalent: 'task-fail' },
-
-  // Agent hooks
-  { name: 'agent-spawn', trigger: 'on:agent:spawn', parameters: ['agentConfig'], returnType: 'HookResult', v3Equivalent: 'agent-spawn' },
-  { name: 'agent-terminate', trigger: 'on:agent:terminate', parameters: ['agentId', 'reason'], returnType: 'HookResult', v3Equivalent: 'agent-terminate' },
-  { name: 'agent-message', trigger: 'on:agent:message', parameters: ['from', 'to', 'message'], returnType: 'HookResult', v3Equivalent: 'agent-message' },
-  { name: 'agent-error', trigger: 'on:agent:error', parameters: ['agentId', 'error'], returnType: 'HookResult', v3Equivalent: 'agent-error' },
-
-  // Swarm hooks
-  { name: 'swarm-init', trigger: 'on:swarm:init', parameters: ['topology', 'config'], returnType: 'HookResult', v3Equivalent: 'swarm-init' },
-  { name: 'swarm-scale', trigger: 'on:swarm:scale', parameters: ['direction', 'count'], returnType: 'HookResult', v3Equivalent: 'swarm-scale' },
-  { name: 'swarm-consensus', trigger: 'on:swarm:consensus', parameters: ['proposal', 'result'], returnType: 'HookResult', v3Equivalent: 'swarm-consensus' },
-  { name: 'swarm-broadcast', trigger: 'on:swarm:broadcast', parameters: ['message'], returnType: 'HookResult', v3Equivalent: 'swarm-broadcast' },
-
-  // Memory hooks
-  { name: 'memory-store', trigger: 'on:memory:store', parameters: ['entry'], returnType: 'HookResult', v3Equivalent: 'memory-store' },
-  { name: 'memory-retrieve', trigger: 'on:memory:retrieve', parameters: ['query', 'results'], returnType: 'HookResult', v3Equivalent: 'memory-retrieve' },
-  { name: 'memory-delete', trigger: 'on:memory:delete', parameters: ['id'], returnType: 'HookResult', v3Equivalent: 'memory-delete' },
-  { name: 'memory-consolidate', trigger: 'on:memory:consolidate', parameters: [], returnType: 'HookResult', v3Equivalent: 'memory-consolidate' },
-
-  // Learning hooks
-  { name: 'learning-pattern', trigger: 'on:learning:pattern', parameters: ['pattern'], returnType: 'HookResult', v3Equivalent: 'learning-pattern' },
-  { name: 'learning-reward', trigger: 'on:learning:reward', parameters: ['trajectory', 'reward'], returnType: 'HookResult', v3Equivalent: 'learning-reward' },
-  { name: 'learning-distill', trigger: 'on:learning:distill', parameters: ['memories'], returnType: 'HookResult', v3Equivalent: 'learning-distill' },
-  { name: 'learning-consolidate', trigger: 'on:learning:consolidate', parameters: [], returnType: 'HookResult', v3Equivalent: 'learning-consolidate' },
-
-  // Session hooks
-  { name: 'session-start', trigger: 'on:session:start', parameters: ['sessionId'], returnType: 'HookResult', v3Equivalent: 'session-start' },
-  { name: 'session-end', trigger: 'on:session:end', parameters: ['sessionId', 'metrics'], returnType: 'HookResult', v3Equivalent: 'session-end' },
-  { name: 'session-resume', trigger: 'on:session:resume', parameters: ['sessionId'], returnType: 'HookResult', v3Equivalent: 'session-resume' },
-  { name: 'session-pause', trigger: 'on:session:pause', parameters: ['sessionId'], returnType: 'HookResult', v3Equivalent: 'session-pause' },
-
-  // Config hooks
-  { name: 'config-load', trigger: 'on:config:load', parameters: ['config'], returnType: 'HookResult', v3Equivalent: 'config-load' },
-  { name: 'config-save', trigger: 'on:config:save', parameters: ['config'], returnType: 'HookResult', v3Equivalent: 'config-save' },
-  { name: 'config-change', trigger: 'on:config:change', parameters: ['key', 'oldValue', 'newValue'], returnType: 'HookResult', v3Equivalent: 'config-change' },
-
-  // Error hooks
-  { name: 'error-global', trigger: 'on:error:global', parameters: ['error'], returnType: 'HookResult', v3Equivalent: 'error-global' },
-  { name: 'error-recover', trigger: 'on:error:recover', parameters: ['error', 'strategy'], returnType: 'HookResult', v3Equivalent: 'error-recover' },
-
-  // Performance hooks
-  { name: 'perf-threshold', trigger: 'on:perf:threshold', parameters: ['metric', 'value'], returnType: 'HookResult', v3Equivalent: 'perf-threshold' },
-  { name: 'perf-report', trigger: 'on:perf:report', parameters: ['report'], returnType: 'HookResult', v3Equivalent: 'perf-report' },
-
-  // Security hooks
-  { name: 'security-alert', trigger: 'on:security:alert', parameters: ['alert'], returnType: 'HookResult', v3Equivalent: 'security-alert' },
-  { name: 'security-block', trigger: 'on:security:block', parameters: ['operation', 'reason'], returnType: 'HookResult', v3Equivalent: 'security-block' },
-  { name: 'security-audit', trigger: 'on:security:audit', parameters: ['action', 'context'], returnType: 'HookResult', v3Equivalent: 'security-audit' },
-];
-
-/**
- * V2 API Interfaces
- */
-export const V2_API_INTERFACES: V2APIInterface[] = [
-  // Core interfaces
-  {
-    name: 'HiveMind',
-    methods: [
-      { name: 'initialize', signature: '(config?: HiveMindConfig): Promise<void>' },
-      { name: 'spawn', signature: '(type: string, config?: AgentConfig): Promise<Agent>' },
-      { name: 'getStatus', signature: '(): Promise<HiveMindStatus>' },
-      { name: 'shutdown', signature: '(): Promise<void>' },
-    ],
-    v3Equivalent: 'UnifiedSwarmCoordinator',
-  },
-  {
-    name: 'SwarmCoordinator',
-    methods: [
-      { name: 'init', signature: '(topology: string): Promise<void>' },
-      { name: 'addAgent', signature: '(agent: Agent): Promise<void>' },
-      { name: 'removeAgent', signature: '(agentId: string): Promise<void>' },
-      { name: 'broadcast', signature: '(message: Message): Promise<void>' },
-      { name: 'consensus', signature: '(proposal: Proposal): Promise<ConsensusResult>' },
-    ],
-    v3Equivalent: 'UnifiedSwarmCoordinator',
-  },
-  {
-    name: 'MemoryManager',
-    methods: [
-      { name: 'store', signature: '(entry: MemoryEntry): Promise<string>' },
-      { name: 'query', signature: '(search: string): Promise<MemoryEntry[]>' },
-      { name: 'delete', signature: '(id: string): Promise<boolean>' },
-      { name: 'clear', signature: '(): Promise<void>' },
-      { name: 'getStats', signature: '(): Promise<MemoryStats>' },
-    ],
-    v3Equivalent: 'UnifiedMemoryService',
-  },
-  {
-    name: 'AgentManager',
-    methods: [
-      { name: 'spawn', signature: '(config: AgentConfig): Promise<Agent>' },
-      { name: 'terminate', signature: '(id: string): Promise<void>' },
-      { name: 'list', signature: '(): Promise<Agent[]>' },
-      { name: 'getInfo', signature: '(id: string): Promise<AgentInfo>' },
-    ],
-    v3Equivalent: 'AgentLifecycleService',
-  },
-  {
-    name: 'TaskOrchestrator',
-    methods: [
-      { name: 'create', signature: '(definition: TaskDefinition): Promise<Task>' },
-      { name: 'assign', signature: '(taskId: string, agentId: string): Promise<void>' },
-      { name: 'complete', signature: '(taskId: string, result?: any): Promise<void>' },
-      { name: 'getStatus', signature: '(taskId: string): Promise<TaskStatus>' },
-    ],
-    v3Equivalent: 'TaskExecutionService',
-  },
-];
-
-/**
- * Mock V3 service for testing
- */
-interface MockV3Service {
-  cli: {
-    execute: (command: string, args: string[]) => Promise<{ success: boolean; output: string }>;
-    getCommands: () => string[];
-  };
-  mcp: {
-    callTool: (name: string, params: Record<string, unknown>) => Promise<unknown>;
-    getTools: () => string[];
-    translateToolName: (v2Name: string) => string;
-  };
-  hooks: {
-    trigger: (name: string, params: Record<string, unknown>) => Promise<{ handled: boolean; result: unknown }>;
-    getHooks: () => string[];
-  };
-  api: {
-    getClass: (name: string) => { methods: string[] } | null;
-    getClasses: () => string[];
-  };
-}
-
-/**
- * V2 Compatibility Validator
- *
- * Tests V3 implementation against V2 capabilities to ensure backward compatibility.
- */
-export class V2CompatibilityValidator {
-  private readonly v3Service: MockV3Service;
-  private readonly v2Version: string;
-  private readonly v3Version: string;
-  private readonly verbose: boolean;
-
-  constructor(options: {
-    v3Service?: MockV3Service;
-    v2Version?: string;
-    v3Version?: string;
-    verbose?: boolean;
-  } = {}) {
-    this.v3Service = options.v3Service || this.createDefaultMockService();
-    this.v2Version = options.v2Version || '2.0.0';
-    this.v3Version = options.v3Version || '3.0.0';
-    this.verbose = options.verbose || false;
-  }
-
-  /**
-   * Create default mock V3 service for testing
-   */
-  private createDefaultMockService(): MockV3Service {
-    // Tool name mapping from V2 to V3
-    const toolNameMapping: Record<string, string> = {
-      'dispatch_agent': 'agent/spawn',
-      'agents/spawn': 'agent/spawn',
-      'agents/list': 'agent/list',
-      'agents/terminate': 'agent/terminate',
-      'agents/info': 'agent/status',
-      'agent/create': 'agent/spawn',
-      'swarm_status': 'swarm/status',
-      'swarm/get-status': 'swarm/status',
-      'swarm/get-comprehensive-status': 'swarm/status',
-      'mcp__ruv-swarm__swarm_init': 'swarm/init',
-      'mcp__ruv-swarm__swarm_status': 'swarm/status',
-      'mcp__ruv-swarm__agent_spawn': 'agent/spawn',
-      'mcp__ruv-swarm__agent_list': 'agent/list',
-      'mcp__ruv-swarm__agent_metrics': 'agent/status',
-      'memory/query': 'memory/search',
-      'mcp__ruv-swarm__memory_usage': 'memory/list',
-      'config/get': 'config/load',
-      'config/update': 'config/save',
-      'mcp__ruv-swarm__neural_status': 'hooks/metrics',
-      'mcp__ruv-swarm__neural_train': 'hooks/pretrain',
-    };
-
-    const v3Tools = [
-      'agent/spawn', 'agent/list', 'agent/terminate', 'agent/status',
-      'swarm/init', 'swarm/status', 'swarm/scale', 'swarm/consensus', 'swarm/broadcast',
-      'memory/store', 'memory/search', 'memory/delete', 'memory/list',
-      'task/create', 'task/assign', 'task/status', 'task/complete',
-      'config/load', 'config/save',
-      'hooks/metrics', 'hooks/pretrain',
-      'github/pr-create', 'github/pr-review', 'github/issue-create',
-    ];
-
-    const v3Commands = [
-      'init', 'start', 'stop', 'status', 'config',
-      'agent spawn', 'agent list', 'agent terminate', 'agent status',
-      'swarm init', 'swarm status', 'swarm scale',
-      'memory list', 'memory search', 'memory clear',
-      'hooks pre-edit', 'hooks post-edit', 'hooks pre-command', 'hooks post-command',
-      'hooks route', 'hooks pretrain', 'hooks metrics',
-    ];
-
-    const v3Hooks = V2_HOOKS.map(h => h.v3Equivalent || h.name);
-
-    const v3Classes = ['UnifiedSwarmCoordinator', 'UnifiedMemoryService', 'AgentLifecycleService', 'TaskExecutionService'];
-
-    return {
-      cli: {
-        execute: vi.fn().mockImplementation(async (command: string) => {
-          const isSupported = v3Commands.some(c => c === command || command.startsWith(c.split(' ')[0]));
-          return { success: isSupported, output: isSupported ? 'OK' : 'Command not found' };
-        }),
-        getCommands: vi.fn().mockReturnValue(v3Commands),
-      },
-      mcp: {
-        callTool: vi.fn().mockImplementation(async (name: string) => {
-          const v3Name = toolNameMapping[name] || name;
-          const isSupported = v3Tools.includes(v3Name);
-          if (!isSupported) throw new Error(`Tool not found: ${name}`);
-          return { success: true };
-        }),
-        getTools: vi.fn().mockReturnValue(v3Tools),
-        translateToolName: vi.fn().mockImplementation((v2Name: string) => toolNameMapping[v2Name] || v2Name),
-      },
-      hooks: {
-        trigger: vi.fn().mockImplementation(async (name: string) => {
-          const isSupported = v3Hooks.includes(name);
-          return { handled: isSupported, result: isSupported ? {} : null };
-        }),
-        getHooks: vi.fn().mockReturnValue(v3Hooks),
-      },
-      api: {
-        getClass: vi.fn().mockImplementation((name: string) => {
-          const mapping: Record<string, { methods: string[] }> = {
-            'UnifiedSwarmCoordinator': { methods: ['initialize', 'spawn', 'addAgent', 'removeAgent', 'broadcast', 'consensus', 'getStatus', 'shutdown'] },
-            'UnifiedMemoryService': { methods: ['store', 'search', 'delete', 'clear', 'getStats'] },
-            'AgentLifecycleService': { methods: ['spawn', 'terminate', 'list', 'getInfo', 'getStatus'] },
-            'TaskExecutionService': { methods: ['create', 'assign', 'complete', 'getStatus'] },
-          };
-          return mapping[name] || null;
-        }),
-        getClasses: vi.fn().mockReturnValue(v3Classes),
-      },
-    };
-  }
-
-  /**
-   * Validate CLI command compatibility
-   */
-  async validateCLI(): Promise<ValidationResult> {
-    const startTime = Date.now();
-    const checks: ValidationCheck[] = [];
-    const v3Commands = this.v3Service.cli.getCommands();
-
-    for (const cmd of V2_CLI_COMMANDS) {
-      const v3Equivalent = cmd.v3Equivalent || cmd.name;
-      const isSupported = v3Commands.some(c =>
-        c === v3Equivalent || c.startsWith(v3Equivalent.split(' ')[0])
-      );
-
-      // Check command exists
-      checks.push({
-        name: `CLI: ${cmd.name}`,
-        category: 'cli',
-        passed: isSupported,
-        message: isSupported
-          ? `Command "${cmd.name}" is supported via "${v3Equivalent}"`
-          : `Command "${cmd.name}" is not available in V3`,
-        v2Behavior: `Execute "${cmd.name}" with flags: ${cmd.flags.join(', ') || 'none'}`,
-        v3Behavior: isSupported
-          ? `Execute "${v3Equivalent}"`
-          : 'Not available',
-        breaking: !isSupported && !cmd.deprecated,
-        migrationPath: isSupported ? `Use "${v3Equivalent}" instead` : undefined,
-      });
-
-      // Check aliases
-      for (const alias of cmd.aliases) {
-        const aliasSupported = v3Commands.some(c => c === alias || c.startsWith(alias.split(' ')[0]));
-        checks.push({
-          name: `CLI Alias: ${alias}`,
-          category: 'cli',
-          passed: aliasSupported || isSupported,
-          message: aliasSupported
-            ? `Alias "${alias}" is supported`
-            : `Alias "${alias}" not directly supported, use "${v3Equivalent}"`,
-          v2Behavior: `Execute "${alias}"`,
-          v3Behavior: aliasSupported ? `Execute "${alias}"` : `Execute "${v3Equivalent}"`,
-          breaking: false,
-          migrationPath: `Use "${v3Equivalent}" for consistent behavior`,
-        });
-      }
-
-      // Check flags
-      for (const flag of cmd.flags) {
-        checks.push({
-          name: `CLI Flag: ${cmd.name} ${flag}`,
-          category: 'cli',
-          passed: isSupported, // Assume flags are supported if command is
-          message: isSupported
-            ? `Flag "${flag}" is expected to work with "${v3Equivalent}"`
-            : `Flag "${flag}" not available (command not supported)`,
-          v2Behavior: `Use "${flag}" with "${cmd.name}"`,
-          v3Behavior: isSupported ? `Use "${flag}" with "${v3Equivalent}"` : 'Not available',
-          breaking: !isSupported && !cmd.deprecated,
-        });
-      }
-    }
-
-    const passedChecks = checks.filter(c => c.passed).length;
-    const breakingChanges = checks.filter(c => c.breaking).length;
-
-    return {
-      category: 'cli',
-      totalChecks: checks.length,
-      passedChecks,
-      failedChecks: checks.length - passedChecks,
-      breakingChanges,
-      checks,
-      duration: Date.now() - startTime,
-    };
-  }
-
-  /**
-   * Validate MCP tool compatibility
-   */
-  async validateMCPTools(): Promise<ValidationResult> {
-    const startTime = Date.now();
-    const checks: ValidationCheck[] = [];
-    const v3Tools = this.v3Service.mcp.getTools();
-
-    for (const tool of V2_MCP_TOOLS) {
-      const v3Equivalent = this.v3Service.mcp.translateToolName(tool.name);
-      const isSupported = v3Tools.includes(v3Equivalent);
-
-      // Check tool exists
-      checks.push({
-        name: `MCP Tool: ${tool.name}`,
-        category: 'mcp',
-        passed: isSupported,
-        message: isSupported
-          ? `Tool "${tool.name}" maps to "${v3Equivalent}"`
-          : `Tool "${tool.name}" has no V3 equivalent`,
-        v2Behavior: `Call "${tool.name}" with params`,
-        v3Behavior: isSupported
-          ? `Call "${v3Equivalent}" with translated params`
-          : 'Not available',
-        breaking: !isSupported && !tool.deprecated,
-        migrationPath: isSupported ? `Use "${v3Equivalent}" with updated parameters` : undefined,
-        details: {
-          v2Parameters: tool.parameters,
-          v3Equivalent,
-        },
-      });
-
-      // Check parameter translation
-      if (isSupported) {
-        for (const [paramName, paramDef] of Object.entries(tool.parameters)) {
-          checks.push({
-            name: `MCP Param: ${tool.name}.${paramName}`,
-            category: 'mcp',
-            passed: true, // Assume param translation works
-            message: `Parameter "${paramName}" (${paramDef.type}) is translated`,
-            v2Behavior: `Pass "${paramName}" as ${paramDef.type}`,
-            v3Behavior: `Translated to V3 format`,
-            breaking: false,
-          });
-        }
-      }
-    }
-
-    const passedChecks = checks.filter(c => c.passed).length;
-    const breakingChanges = checks.filter(c => c.breaking).length;
-
-    return {
-      category: 'mcp',
-      totalChecks: checks.length,
-      passedChecks,
-      failedChecks: checks.length - passedChecks,
-      breakingChanges,
-      checks,
-      duration: Date.now() - startTime,
-    };
-  }
-
-  /**
-   * Validate hook compatibility
-   */
-  async validateHooks(): Promise<ValidationResult> {
-    const startTime = Date.now();
-    const checks: ValidationCheck[] = [];
-    const v3Hooks = this.v3Service.hooks.getHooks();
-
-    for (const hook of V2_HOOKS) {
-      const v3Equivalent = hook.v3Equivalent || hook.name;
-      const isSupported = v3Hooks.includes(v3Equivalent);
-
-      // Check hook exists
-      checks.push({
-        name: `Hook: ${hook.name}`,
-        category: 'hooks',
-        passed: isSupported,
-        message: isSupported
-          ? `Hook "${hook.name}" is supported as "${v3Equivalent}"`
-          : `Hook "${hook.name}" is not available in V3`,
-        v2Behavior: `Trigger on "${hook.trigger}" with params: ${hook.parameters.join(', ')}`,
-        v3Behavior: isSupported
-          ? `Trigger "${v3Equivalent}" with translated params`
-          : 'Not available',
-        breaking: !isSupported && !hook.deprecated,
-        migrationPath: isSupported ? `Listen for "${v3Equivalent}" instead` : undefined,
-        details: {
-          v2Trigger: hook.trigger,
-          v2Parameters: hook.parameters,
-          v3Equivalent,
-        },
-      });
-
-      // Check parameters
-      for (const param of hook.parameters) {
-        checks.push({
-          name: `Hook Param: ${hook.name}.${param}`,
-          category: 'hooks',
-          passed: isSupported, // Assume params work if hook works
-          message: isSupported
-            ? `Parameter "${param}" is passed to hook`
-            : `Parameter "${param}" not available (hook not supported)`,
-          v2Behavior: `Receive "${param}" in hook handler`,
-          v3Behavior: isSupported ? 'Translated parameter available' : 'Not available',
-          breaking: !isSupported,
-        });
-      }
-
-      // Check return type compatibility
-      checks.push({
-        name: `Hook Return: ${hook.name}`,
-        category: 'hooks',
-        passed: isSupported,
-        message: isSupported
-          ? `Return type "${hook.returnType}" is compatible`
-          : `Return type not available (hook not supported)`,
-        v2Behavior: `Return ${hook.returnType}`,
-        v3Behavior: isSupported ? `Return compatible ${hook.returnType}` : 'Not available',
-        breaking: !isSupported,
-      });
-    }
-
-    const passedChecks = checks.filter(c => c.passed).length;
-    const breakingChanges = checks.filter(c => c.breaking).length;
-
-    return {
-      category: 'hooks',
-      totalChecks: checks.length,
-      passedChecks,
-      failedChecks: checks.length - passedChecks,
-      breakingChanges,
-      checks,
-      duration: Date.now() - startTime,
-    };
-  }
-
-  /**
-   * Validate API compatibility
-   */
-  async validateAPI(): Promise<ValidationResult> {
-    const startTime = Date.now();
-    const checks: ValidationCheck[] = [];
-    const v3Classes = this.v3Service.api.getClasses();
-
-    for (const iface of V2_API_INTERFACES) {
-      const v3Equivalent = iface.v3Equivalent || iface.name;
-      const v3Class = this.v3Service.api.getClass(v3Equivalent);
-      const isSupported = v3Class !== null;
-
-      // Check class exists
-      checks.push({
-        name: `API Class: ${iface.name}`,
-        category: 'api',
-        passed: isSupported,
-        message: isSupported
-          ? `Class "${iface.name}" is available as "${v3Equivalent}"`
-          : `Class "${iface.name}" has no V3 equivalent`,
-        v2Behavior: `Import and use "${iface.name}"`,
-        v3Behavior: isSupported
-          ? `Import "${v3Equivalent}" from @claude-flow/*`
-          : 'Not available',
-        breaking: !isSupported && !iface.deprecated,
-        migrationPath: isSupported
-          ? `Use "${v3Equivalent}" with import alias`
-          : undefined,
-      });
-
-      // Check methods
-      for (const method of iface.methods) {
-        const methodAvailable = v3Class?.methods.some(m =>
-          m === method.name || m.toLowerCase() === method.name.toLowerCase()
-        );
-
-        checks.push({
-          name: `API Method: ${iface.name}.${method.name}`,
-          category: 'api',
-          passed: methodAvailable || false,
-          message: methodAvailable
-            ? `Method "${method.name}" is available`
-            : `Method "${method.name}" may have different name or signature`,
-          v2Behavior: `Call ${iface.name}.${method.name}${method.signature}`,
-          v3Behavior: methodAvailable
-            ? `Call ${v3Equivalent}.${method.name}()`
-            : 'May need migration',
-          breaking: !methodAvailable && !iface.deprecated,
-          migrationPath: methodAvailable
-            ? 'Same method signature'
-            : 'Check V3 API documentation',
-        });
-      }
-    }
-
-    const passedChecks = checks.filter(c => c.passed).length;
-    const breakingChanges = checks.filter(c => c.breaking).length;
-
-    return {
-      category: 'api',
-      totalChecks: checks.length,
-      passedChecks,
-      failedChecks: checks.length - passedChecks,
-      breakingChanges,
-      checks,
-      duration: Date.now() - startTime,
-    };
-  }
-
-  /**
-   * Run full validation suite
-   */
-  async runFullValidation(): Promise<FullValidationReport> {
-    const startTime = Date.now();
-
-    this.log('Starting V2 Compatibility Validation...');
-
-    this.log('Validating CLI commands...');
-    const cliResult = await this.validateCLI();
-
-    this.log('Validating MCP tools...');
-    const mcpResult = await this.validateMCPTools();
-
-    this.log('Validating hooks...');
-    const hooksResult = await this.validateHooks();
-
-    this.log('Validating API interfaces...');
-    const apiResult = await this.validateAPI();
-
-    const totalChecks = cliResult.totalChecks + mcpResult.totalChecks + hooksResult.totalChecks + apiResult.totalChecks;
-    const passedChecks = cliResult.passedChecks + mcpResult.passedChecks + hooksResult.passedChecks + apiResult.passedChecks;
-    const failedChecks = totalChecks - passedChecks;
-    const breakingChanges = cliResult.breakingChanges + mcpResult.breakingChanges + hooksResult.breakingChanges + apiResult.breakingChanges;
-
-    const overallPassed = breakingChanges === 0;
-
-    const recommendations = this.generateRecommendations(cliResult, mcpResult, hooksResult, apiResult);
-
-    const report: FullValidationReport = {
-      timestamp: new Date(),
-      v2Version: this.v2Version,
-      v3Version: this.v3Version,
-      overallPassed,
-      totalChecks,
-      passedChecks,
-      failedChecks,
-      breakingChanges,
-      cli: cliResult,
-      mcp: mcpResult,
-      hooks: hooksResult,
-      api: apiResult,
-      summary: this.generateSummary(cliResult, mcpResult, hooksResult, apiResult, overallPassed),
-      recommendations,
-      duration: Date.now() - startTime,
-    };
-
-    this.log('Validation complete.');
-
-    return report;
-  }
-
-  /**
-   * Generate recommendations based on results
-   */
-  private generateRecommendations(
-    cli: ValidationResult,
-    mcp: ValidationResult,
-    hooks: ValidationResult,
-    api: ValidationResult
-  ): string[] {
-    const recommendations: string[] = [];
-
-    if (cli.breakingChanges > 0) {
-      recommendations.push('Update CLI command calls to use V3 equivalents');
-      recommendations.push('Run migration script: npx @claude-flow/cli migrate');
-    }
-
-    if (mcp.breakingChanges > 0) {
-      recommendations.push('Enable V2 compatibility mode in MCP server configuration');
-      recommendations.push('Update tool calls to use new naming convention (e.g., agent/spawn)');
-    }
-
-    if (hooks.breakingChanges > 0) {
-      recommendations.push('Review hook configuration for renamed or removed hooks');
-      recommendations.push('Update hook listeners to use V3 event names');
-    }
-
-    if (api.breakingChanges > 0) {
-      recommendations.push('Update import statements to use @claude-flow/* packages');
-      recommendations.push('Use provided import aliases for backward compatibility');
-    }
-
-    if (cli.passedChecks < cli.totalChecks) {
-      recommendations.push('Some CLI aliases may not be directly supported - use canonical command names');
-    }
-
-    if (mcp.passedChecks < mcp.totalChecks) {
-      recommendations.push('Consider using tool name translation layer for gradual migration');
-    }
-
-    if (recommendations.length === 0) {
-      recommendations.push('No migration actions required - V2 code is fully compatible');
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * Generate human-readable summary
-   */
-  private generateSummary(
-    cli: ValidationResult,
-    mcp: ValidationResult,
-    hooks: ValidationResult,
-    api: ValidationResult,
-    overallPassed: boolean
-  ): string {
-    const lines: string[] = [
-      '='.repeat(70),
-      '           V2 COMPATIBILITY VALIDATION REPORT',
-      '='.repeat(70),
-      '',
-      `Status: ${overallPassed ? 'PASSED - No breaking changes detected' : 'FAILED - Breaking changes detected'}`,
-      '',
-      'Category Summary:',
-      '-'.repeat(70),
-      `CLI Commands:    ${cli.passedChecks}/${cli.totalChecks} passed (${cli.breakingChanges} breaking)`,
-      `MCP Tools:       ${mcp.passedChecks}/${mcp.totalChecks} passed (${mcp.breakingChanges} breaking)`,
-      `Hooks:           ${hooks.passedChecks}/${hooks.totalChecks} passed (${hooks.breakingChanges} breaking)`,
-      `API Interfaces:  ${api.passedChecks}/${api.totalChecks} passed (${api.breakingChanges} breaking)`,
-      '-'.repeat(70),
-      '',
-    ];
-
-    if (!overallPassed) {
-      lines.push('Breaking Changes Detected:');
-      lines.push('');
-
-      const allBreaking = [
-        ...cli.checks.filter(c => c.breaking).map(c => `  CLI: ${c.name}`),
-        ...mcp.checks.filter(c => c.breaking).map(c => `  MCP: ${c.name}`),
-        ...hooks.checks.filter(c => c.breaking).map(c => `  Hooks: ${c.name}`),
-        ...api.checks.filter(c => c.breaking).map(c => `  API: ${c.name}`),
-      ].slice(0, 20);
-
-      lines.push(...allBreaking);
-
-      if (cli.breakingChanges + mcp.breakingChanges + hooks.breakingChanges + api.breakingChanges > 20) {
-        lines.push(`  ... and ${cli.breakingChanges + mcp.breakingChanges + hooks.breakingChanges + api.breakingChanges - 20} more`);
-      }
-
-      lines.push('');
-    }
-
-    lines.push('='.repeat(70));
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Log message if verbose mode is enabled
-   */
-  private log(message: string): void {
-    if (this.verbose) {
-      console.log(`[V2Compat] ${message}`);
-    }
-  }
-}
-
-/**
- * Generate markdown compatibility report
- */
-export function generateCompatibilityReport(report: FullValidationReport): string {
-  const lines: string[] = [
-    '# V2 Compatibility Validation Report',
-    '',
-    `> Generated: ${report.timestamp.toISOString()}`,
-    `> V2 Version: ${report.v2Version}`,
-    `> V3 Version: ${report.v3Version}`,
-    '',
-    '## Executive Summary',
-    '',
-    `**Status**: ${report.overallPassed ? 'PASSED' : 'FAILED'}`,
-    '',
-    '| Metric | Value |',
-    '|--------|-------|',
-    `| Total Checks | ${report.totalChecks} |`,
-    `| Passed | ${report.passedChecks} |`,
-    `| Failed | ${report.failedChecks} |`,
-    `| Breaking Changes | ${report.breakingChanges} |`,
-    `| Duration | ${report.duration}ms |`,
-    '',
-    '## Category Results',
-    '',
-    '### CLI Commands',
-    '',
-    `- **Total**: ${report.cli.totalChecks}`,
-    `- **Passed**: ${report.cli.passedChecks}`,
-    `- **Failed**: ${report.cli.failedChecks}`,
-    `- **Breaking**: ${report.cli.breakingChanges}`,
-    '',
-    '| Command | Status | Migration |',
-    '|---------|--------|-----------|',
-    ...report.cli.checks
-      .filter(c => c.name.startsWith('CLI:'))
-      .slice(0, 30)
-      .map(c => `| ${c.name.replace('CLI: ', '')} | ${c.passed ? 'OK' : 'FAIL'} | ${c.migrationPath || 'N/A'} |`),
-    '',
-    '### MCP Tools',
-    '',
-    `- **Total**: ${report.mcp.totalChecks}`,
-    `- **Passed**: ${report.mcp.passedChecks}`,
-    `- **Failed**: ${report.mcp.failedChecks}`,
-    `- **Breaking**: ${report.mcp.breakingChanges}`,
-    '',
-    '| Tool | Status | V3 Equivalent |',
-    '|------|--------|---------------|',
-    ...report.mcp.checks
-      .filter(c => c.name.startsWith('MCP Tool:'))
-      .slice(0, 40)
-      .map(c => {
-        const v3Name = c.details?.v3Equivalent as string || 'N/A';
-        return `| ${c.name.replace('MCP Tool: ', '')} | ${c.passed ? 'OK' : 'FAIL'} | ${v3Name} |`;
-      }),
-    '',
-    '### Hooks',
-    '',
-    `- **Total**: ${report.hooks.totalChecks}`,
-    `- **Passed**: ${report.hooks.passedChecks}`,
-    `- **Failed**: ${report.hooks.failedChecks}`,
-    `- **Breaking**: ${report.hooks.breakingChanges}`,
-    '',
-    '| Hook | Status | V3 Trigger |',
-    '|------|--------|------------|',
-    ...report.hooks.checks
-      .filter(c => c.name.startsWith('Hook:') && !c.name.includes('Param') && !c.name.includes('Return'))
-      .slice(0, 50)
-      .map(c => {
-        const v3Name = c.details?.v3Equivalent as string || 'N/A';
-        return `| ${c.name.replace('Hook: ', '')} | ${c.passed ? 'OK' : 'FAIL'} | ${v3Name} |`;
-      }),
-    '',
-    '### API Interfaces',
-    '',
-    `- **Total**: ${report.api.totalChecks}`,
-    `- **Passed**: ${report.api.passedChecks}`,
-    `- **Failed**: ${report.api.failedChecks}`,
-    `- **Breaking**: ${report.api.breakingChanges}`,
-    '',
-    '| Interface/Method | Status | Migration |',
-    '|------------------|--------|-----------|',
-    ...report.api.checks
-      .slice(0, 30)
-      .map(c => `| ${c.name.replace('API ', '')} | ${c.passed ? 'OK' : 'FAIL'} | ${c.migrationPath || 'N/A'} |`),
-    '',
-    '## Breaking Changes',
-    '',
-  ];
-
-  const breakingChecks = [
-    ...report.cli.checks.filter(c => c.breaking),
-    ...report.mcp.checks.filter(c => c.breaking),
-    ...report.hooks.checks.filter(c => c.breaking),
-    ...report.api.checks.filter(c => c.breaking),
-  ];
-
-  if (breakingChecks.length === 0) {
-    lines.push('No breaking changes detected.');
-  } else {
-    lines.push('| Category | Item | V2 Behavior | V3 Behavior |');
-    lines.push('|----------|------|-------------|-------------|');
-    for (const check of breakingChecks.slice(0, 50)) {
-      lines.push(`| ${check.category.toUpperCase()} | ${check.name} | ${check.v2Behavior} | ${check.v3Behavior} |`);
-    }
-  }
-
-  lines.push('');
-  lines.push('## Recommendations');
-  lines.push('');
-  for (const rec of report.recommendations) {
-    lines.push(`- ${rec}`);
-  }
-
-  lines.push('');
-  lines.push('## Migration Guide');
-  lines.push('');
-  lines.push('### CLI Migration');
-  lines.push('');
-  lines.push('```bash');
-  lines.push('# V2 commands are supported via compatibility layer');
-  lines.push('# Deprecated commands will show warnings');
-  lines.push('');
-  lines.push('# V2 (deprecated)');
-  lines.push('npx claude-flow hive-mind init');
-  lines.push('');
-  lines.push('# V3 (recommended)');
-  lines.push('npx @claude-flow/cli swarm init');
-  lines.push('```');
-  lines.push('');
-  lines.push('### MCP Tool Migration');
-  lines.push('');
-  lines.push('```typescript');
-  lines.push('// V2 tool call');
-  lines.push("await mcp.callTool('dispatch_agent', { type: 'coder' });");
-  lines.push('');
-  lines.push('// V3 tool call (direct)');
-  lines.push("await mcp.callTool('agent/spawn', { agentType: 'coder' });");
-  lines.push('');
-  lines.push('// V3 with compatibility layer');
-  lines.push("await mcp.callTool('dispatch_agent', { type: 'coder' }); // Auto-translated");
-  lines.push('```');
-  lines.push('');
-  lines.push('### API Migration');
-  lines.push('');
-  lines.push('```typescript');
-  lines.push("// V2 imports");
-  lines.push("import { HiveMind } from 'claude-flow/hive-mind';");
-  lines.push("import { SwarmCoordinator } from 'claude-flow/swarm';");
-  lines.push('');
-  lines.push("// V3 imports (using aliases)");
-  lines.push("import { UnifiedSwarmCoordinator as HiveMind } from '@claude-flow/swarm';");
-  lines.push("import { UnifiedSwarmCoordinator as SwarmCoordinator } from '@claude-flow/swarm';");
-  lines.push('```');
-  lines.push('');
-  lines.push('---');
-  lines.push('');
-  lines.push('*Report generated by V2CompatibilityValidator*');
-
-  return lines.join('\n');
-}