snow-flow 3.3.2 → 3.3.4

package/src/cli.ts.backup-20250809-125529

@@ -0,0 +1,4773 @@
+#!/usr/bin/env node
+/**
+ * Minimal CLI for snow-flow - ServiceNow Multi-Agent Framework
+ */
+
+import { Command } from 'commander';
+import dotenv from 'dotenv';
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { spawn, ChildProcess } from 'child_process';
+import * as os from 'os';
+import { existsSync } from 'fs';
+import { ServiceNowOAuth } from './utils/snow-oauth.js';
+import { ServiceNowClient } from './utils/servicenow-client.js';
+import { AgentDetector, TaskAnalysis } from './utils/agent-detector.js';
+import { getNotificationTemplateSysId } from './utils/servicenow-id-generator.js';
+import { VERSION } from './version.js';
+// Snow-Flow CLI integration removed - using direct swarm command implementation
+import { snowFlowSystem } from './snow-flow-system.js';
+import { Logger } from './utils/logger.js';
+import chalk from 'chalk';
+
+// Load environment variables
+dotenv.config();
+
+// Create CLI logger instance
+const cliLogger = new Logger('cli');
+
+const program = new Command();
+
+program
+  .name('snow-flow')
+  .description('ServiceNow Multi-Agent Development Framework')
+  .version(VERSION);
+
+// Flow deprecation handler - check for flow-related commands
+function checkFlowDeprecation(command: string, objective?: string) {
+  const flowKeywords = ['flow', 'create-flow', 'xml-flow', 'flow-designer'];
+  const isFlowCommand = flowKeywords.some(keyword => command.includes(keyword));
+  const isFlowObjective = objective && objective.toLowerCase().includes('flow') && 
+                         !objective.toLowerCase().includes('workflow') &&
+                         !objective.toLowerCase().includes('data flow') &&
+                         !objective.toLowerCase().includes('snow-flow');
+  
+  if (isFlowCommand || isFlowObjective) {
+    console.error('❌ Flow creation has been removed from snow-flow v1.4.0+');
+    console.error('');
+    console.error('Please use ServiceNow Flow Designer directly:');
+    console.error('1. Log into your ServiceNow instance');
+    console.error('2. Navigate to: Flow Designer > Designer');
+    console.error('3. Create flows using the visual interface');
+    console.error('');
+    console.error('Snow-flow continues to support:');
+    console.error('- Widget development');
+    console.error('- Update Set management');
+    console.error('- Table/field discovery');
+    console.error('- General ServiceNow operations');
+    process.exit(1);
+  }
+}
+
+
+// Swarm command - the main orchestration command with EVERYTHING
+program
+  .command('swarm <objective>')
+  .description('Execute multi-agent orchestration for a ServiceNow task - één command voor alles!')
+  .option('--strategy <strategy>', 'Execution strategy (development, _analysis, research)', 'development')
+  .option('--mode <mode>', 'Coordination mode (hierarchical, mesh, distributed)', 'hierarchical')
+  .option('--max-agents <number>', 'Maximum number of agents', '5')
+  .option('--parallel', 'Enable parallel execution')
+  .option('--monitor', 'Enable real-time monitoring')
+  .option('--auto-permissions', 'Automatic permission escalation when needed')
+  .option('--smart-discovery', 'Smart artifact discovery and reuse (default: true)', true)
+  .option('--no-smart-discovery', 'Disable smart artifact discovery')
+  .option('--live-testing', 'Enable live testing during development (default: true)', true)
+  .option('--no-live-testing', 'Disable live testing')
+  .option('--auto-deploy', 'Automatic deployment when ready (default: true)', true)
+  .option('--no-auto-deploy', 'Disable automatic deployment')
+  .option('--auto-rollback', 'Automatic rollback on failures (default: true)', true)
+  .option('--no-auto-rollback', 'Disable automatic rollback')
+  .option('--shared-memory', 'Enable shared memory between agents (default: true)', true)
+  .option('--no-shared-memory', 'Disable shared memory')
+  .option('--progress-monitoring', 'Real-time progress monitoring (default: true)', true)
+  .option('--no-progress-monitoring', 'Disable progress monitoring')
+  .option('--xml-first', 'Use XML-first approach for flow creation (MOST RELIABLE!)')
+  .option('--xml-output <path>', 'Save generated XML to specific path (with --xml-first)')
+  .option('--autonomous-documentation', 'Enable autonomous documentation system (default: true)', true)
+  .option('--no-autonomous-documentation', 'Disable autonomous documentation system')
+  .option('--autonomous-cost-optimization', 'Enable autonomous cost optimization engine (default: true)', true)
+  .option('--no-autonomous-cost-optimization', 'Disable autonomous cost optimization engine')
+  .option('--autonomous-compliance', 'Enable autonomous compliance monitoring (default: true)', true)
+  .option('--no-autonomous-compliance', 'Disable autonomous compliance monitoring')
+  .option('--autonomous-healing', 'Enable autonomous self-healing capabilities (default: true)', true)
+  .option('--no-autonomous-healing', 'Disable autonomous self-healing capabilities')
+  .option('--autonomous-all', 'Force enable all autonomous systems (overrides individual --no- flags)')
+  .option('--no-autonomous-all', 'Disable all autonomous systems (overrides individual settings)')
+  .option('--verbose', 'Show detailed execution information')
+  .action(async (objective: string, options) => {
+    // Check for flow deprecation first
+    checkFlowDeprecation('swarm', objective);
+    
+    // Always show essential info
+    cliLogger.info(`\n🚀 Snow-Flow v${VERSION}`);
+    cliLogger.info(`📋 Objective: ${objective}`);
+    
+    // Only show detailed config in verbose mode
+    if (options.verbose) {
+      cliLogger.info(`⚙️  Strategy: ${options.strategy} | Mode: ${options.mode} | Max Agents: ${options.maxAgents}`);
+      cliLogger.info(`🔄 Parallel: ${options.parallel ? 'Yes' : 'No'} | Monitor: ${options.monitor ? 'Yes' : 'No'}`);
+      
+      // Show new intelligent features
+      cliLogger.info(`\n🧠 Intelligent Features:`);
+      cliLogger.info(`  🔐 Auto Permissions: ${options.autoPermissions ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  🔍 Smart Discovery: ${options.smartDiscovery ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  🧪 Live Testing: ${options.liveTesting ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  🚀 Auto Deploy: ${options.autoDeploy ? '✅ DEPLOYMENT MODE - WILL CREATE REAL ARTIFACTS' : '❌ PLANNING MODE - ANALYSIS ONLY'}`);
+      cliLogger.info(`  🔄 Auto Rollback: ${options.autoRollback ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  💾 Shared Memory: ${options.sharedMemory ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  📊 Progress Monitoring: ${options.progressMonitoring ? '✅ Yes' : '❌ No'}`);
+      
+      // Calculate actual autonomous system states (with override logic)
+      // Commander.js converts --no-autonomous-all to autonomousAll: false
+      const noAutonomousAll = options.autonomousAll === false;
+      const forceAutonomousAll = options.autonomousAll === true;
+      
+      const autonomousDocActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousDocumentation !== false;
+      
+      const autonomousCostActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousCostOptimization !== false;
+      
+      const autonomousComplianceActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousCompliance !== false;
+      
+      const autonomousHealingActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousHealing !== false;
+      
+      const hasAutonomousSystems = autonomousDocActive || autonomousCostActive || 
+        autonomousComplianceActive || autonomousHealingActive;
+      
+      cliLogger.info(`\n🤖 Autonomous Systems (DEFAULT ENABLED):`);
+      cliLogger.info(`  📚 Documentation: ${autonomousDocActive ? '✅ ACTIVE' : '❌ Disabled'}`);
+      cliLogger.info(`  💰 Cost Optimization: ${autonomousCostActive ? '✅ ACTIVE' : '❌ Disabled'}`);
+      cliLogger.info(`  🔐 Compliance Monitoring: ${autonomousComplianceActive ? '✅ ACTIVE' : '❌ Disabled'}`);
+      cliLogger.info(`  🏥 Self-Healing: ${autonomousHealingActive ? '✅ ACTIVE' : '❌ Disabled'}`);
+      cliLogger.info('');
+    } else {
+      // In non-verbose mode, only show critical info
+      if (options.autoDeploy) {
+        cliLogger.info(`🚀 Auto-Deploy: ENABLED - Will create real artifacts in ServiceNow`);
+      }
+      
+      // Calculate autonomous systems for non-verbose mode (same logic as verbose)
+      const noAutonomousAll = options.autonomousAll === false;
+      const forceAutonomousAll = options.autonomousAll === true;
+      
+      const autonomousDocActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousDocumentation !== false;
+      
+      const autonomousCostActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousCostOptimization !== false;
+      
+      const autonomousComplianceActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousCompliance !== false;
+      
+      const autonomousHealingActive = noAutonomousAll ? false : 
+        forceAutonomousAll ? true : 
+        options.autonomousHealing !== false;
+      
+      // Show active autonomous systems
+      const activeSystems = [];
+      if (autonomousDocActive) activeSystems.push('📚 Documentation');
+      if (autonomousCostActive) activeSystems.push('💰 Cost Optimization');
+      if (autonomousComplianceActive) activeSystems.push('🔐 Compliance');
+      if (autonomousHealingActive) activeSystems.push('🏥 Self-Healing');
+      
+      if (activeSystems.length > 0) {
+        cliLogger.info(`🤖 Autonomous Systems: ${activeSystems.join(', ')}`);
+      } else {
+        cliLogger.info(`🤖 Autonomous Systems: ❌ All Disabled`);
+      }
+    }
+    
+    // Analyze the objective using intelligent agent detection
+    const taskAnalysis = analyzeObjective(objective, parseInt(options.maxAgents));
+    
+    // Debug logging to understand task type detection
+    if (process.env.DEBUG || options.verbose) {
+      if (process.env.DEBUG) {
+        cliLogger.info(`🔍 DEBUG - Detected artifacts: [${taskAnalysis.serviceNowArtifacts.join(', ')}]`);
+        cliLogger.info(`🔍 DEBUG - Flow keywords in objective: ${objective.toLowerCase().includes('flow')}`);
+        cliLogger.info(`🔍 DEBUG - Widget keywords in objective: ${objective.toLowerCase().includes('widget')}`);
+      }
+      
+      cliLogger.info(`\n📊 Task Analysis:`);
+      cliLogger.info(`  🎯 Task Type: ${taskAnalysis.taskType}`);
+      cliLogger.info(`  🧠 Primary Agent: ${taskAnalysis.primaryAgent}`);
+      cliLogger.info(`  👥 Supporting Agents: ${taskAnalysis.supportingAgents.join(', ')}`);
+      cliLogger.info(`  📊 Complexity: ${taskAnalysis.complexity} | Estimated Agents: ${taskAnalysis.estimatedAgentCount}`);
+      cliLogger.info(`  🔧 ServiceNow Artifacts: ${taskAnalysis.serviceNowArtifacts.join(', ')}`);
+      cliLogger.info(`  📦 Auto Update Set: ${taskAnalysis.requiresUpdateSet ? '✅ Yes' : '❌ No'}`);
+      cliLogger.info(`  🏗️ Auto Application: ${taskAnalysis.requiresApplication ? '✅ Yes' : '❌ No'}`);
+    }
+    
+    // Show timeout configuration only in verbose mode
+    const timeoutMinutes = process.env.SNOW_FLOW_TIMEOUT_MINUTES ? parseInt(process.env.SNOW_FLOW_TIMEOUT_MINUTES) : 60;
+    if (options.verbose) {
+      if (timeoutMinutes > 0) {
+        cliLogger.info(`⏱️  Timeout: ${timeoutMinutes} minutes`);
+      } else {
+        cliLogger.info('⏱️  Timeout: Disabled (infinite execution time)');
+      }
+    }
+    
+    // Check ServiceNow authentication
+    const oauth = new ServiceNowOAuth();
+    const isAuthenticated = await oauth.isAuthenticated();
+    
+    if (options.verbose) {
+      if (isAuthenticated) {
+        cliLogger.info('🔗 ServiceNow connection: ✅ Authenticated');
+        
+        // Test ServiceNow connection
+        const client = new ServiceNowClient();
+        const testResult = await client.testConnection();
+        if (testResult.success) {
+          cliLogger.info(`👤 Connected as: ${testResult.data.name} (${testResult.data.user_name})`);
+        }
+      } else {
+        cliLogger.warn('🔗 ServiceNow connection: ❌ Not authenticated');
+        cliLogger.info('💡 Run "snow-flow auth login" to enable live ServiceNow integration');
+      }
+    } else if (!isAuthenticated) {
+      // In non-verbose mode, only warn if not authenticated
+      cliLogger.warn('⚠️  Not authenticated. Run "snow-flow auth login" for ServiceNow integration');
+    }
+    
+    // Initialize Queen Agent memory system
+    if (options.verbose) {
+      cliLogger.info('\n💾 Initializing swarm memory system...');
+    }
+    const { QueenMemorySystem } = await import('./queen/queen-memory.js');
+    const memorySystem = new QueenMemorySystem();
+    
+    // Generate swarm session ID
+    const sessionId = `swarm_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    cliLogger.info(`\n🔖 Session: ${sessionId}`);
+    
+    // Store swarm session in memory
+    memorySystem.storeLearning(`session_${sessionId}`, {
+      objective,
+      taskAnalysis,
+      options,
+      started_at: new Date().toISOString(),
+      is_authenticated: isAuthenticated
+    });
+    
+    // Check if this is a Flow Designer flow request
+    const isFlowDesignerTask = taskAnalysis.taskType === 'flow_development' || 
+                               taskAnalysis.primaryAgent === 'flow-builder' ||
+                               (objective.toLowerCase().includes('flow') && 
+                                !objective.toLowerCase().includes('workflow') &&
+                                !objective.toLowerCase().includes('data flow'));
+    
+    let xmlFlowResult: any = null;
+    
+    // Start real Claude Code orchestration
+    try {
+      // Generate the Queen Agent orchestration prompt
+      const orchestrationPrompt = buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated, sessionId, isFlowDesignerTask);
+      
+      if (options.verbose) {
+        cliLogger.info('\n👑 Initializing Queen Agent orchestration...');
+        cliLogger.info('🎯 Queen Agent will coordinate the following:');
+        cliLogger.info(`   - Analyze objective: "${objective}"`);
+        cliLogger.info(`   - Spawn ${taskAnalysis.estimatedAgentCount} specialized agents`);
+        cliLogger.info(`   - Coordinate through shared memory (session: ${sessionId})`);
+        cliLogger.info(`   - Monitor progress and adapt strategy`);
+      } else {
+        cliLogger.info('\n👑 Launching Queen Agent...');
+      }
+      
+      // Check if intelligent features are enabled
+      const hasIntelligentFeatures = options.autoPermissions || options.smartDiscovery || 
+        options.liveTesting || options.autoDeploy || options.autoRollback || 
+        options.sharedMemory || options.progressMonitoring;
+      
+      if (options.verbose && hasIntelligentFeatures && isAuthenticated) {
+        cliLogger.info('\n🧠 INTELLIGENT ORCHESTRATION MODE ENABLED!');
+        cliLogger.info('✨ Queen Agent will use advanced features:');
+        
+        if (options.autoPermissions) {
+          cliLogger.info('  🔐 Automatic permission escalation');
+        }
+        if (options.smartDiscovery) {
+          cliLogger.info('  🔍 Smart artifact discovery and reuse');
+        }
+        if (options.liveTesting) {
+          cliLogger.info('  🧪 Real-time testing in ServiceNow');
+        }
+        if (options.autoDeploy) {
+          cliLogger.info('  🚀 Automatic deployment when ready');
+        }
+        if (options.autoRollback) {
+          cliLogger.info('  🔄 Automatic rollback on failures');
+        }
+        if (options.sharedMemory) {
+          cliLogger.info('  💾 Shared context across all agents');
+        }
+        if (options.progressMonitoring) {
+          cliLogger.info('  📊 Real-time progress monitoring');
+        }
+      }
+      
+      if (options.verbose) {
+        if (isAuthenticated) {
+          cliLogger.info('\n🔗 Live ServiceNow integration: ✅ Enabled');
+          cliLogger.info('📝 Artifacts will be created directly in ServiceNow');
+        } else {
+          cliLogger.info('\n🔗 Live ServiceNow integration: ❌ Disabled');
+          cliLogger.info('📝 Artifacts will be saved to servicenow/ directory');
+        }
+      }
+      
+      cliLogger.info('🚀 Launching Claude Code...');
+      
+      // Try to execute Claude Code directly with the prompt
+      const success = await executeClaudeCode(orchestrationPrompt);
+      
+      if (success) {
+        cliLogger.info('✅ Claude Code launched successfully!');
+        
+        if (options.verbose) {
+          cliLogger.info('👑 Queen Agent is now coordinating your swarm');
+          cliLogger.info(`💾 Monitor progress with session ID: ${sessionId}`);
+          
+          if (isAuthenticated && options.autoDeploy) {
+            cliLogger.info('🚀 Real artifacts will be created in ServiceNow');
+          } else {
+            cliLogger.info('📋 Planning mode - _analysis and recommendations only');
+          }
+        }
+        
+        // Store successful launch in memory
+        memorySystem.storeLearning(`launch_${sessionId}`, {
+          success: true,
+          launched_at: new Date().toISOString()
+        });
+      } else {
+        if (options.verbose) {
+          cliLogger.info('\n🚀 SNOW-FLOW ORCHESTRATION COMPLETE!');
+          cliLogger.info('🤖 Now it\'s time for Claude Code agents to do the work...\n');
+          
+          cliLogger.info('👑 QUEEN AGENT ORCHESTRATION PROMPT FOR CLAUDE CODE:');
+          cliLogger.info('=' .repeat(80));
+          cliLogger.info(orchestrationPrompt);
+          cliLogger.info('=' .repeat(80));
+          
+          cliLogger.info('\n✅ Snow-Flow has prepared the orchestration!');
+          cliLogger.info('📊 CRITICAL NEXT STEPS:');
+          cliLogger.info('   1. Copy the ENTIRE prompt above');
+          cliLogger.info('   2. Paste it into Claude Code (the AI assistant)');
+          cliLogger.info('   3. Claude Code will spawn multiple specialized agents as workhorses');
+          cliLogger.info('   4. These agents will implement your flow with all required logic');
+          cliLogger.info('   5. Agents will enhance the basic XML template with real functionality');
+          
+          cliLogger.info('\n🎯 Remember:');
+          cliLogger.info('   - Snow-Flow = Orchestrator (coordinates the work)');
+          cliLogger.info('   - Claude Code = Workhorses (implement the solution)');
+          
+          if (xmlFlowResult) {
+            cliLogger.info(`\n📁 XML template saved at: ${xmlFlowResult.filePath}`);
+            cliLogger.info('   ⚠️  This is just a BASIC template - agents must enhance it!');
+          }
+          
+          if (isAuthenticated && options.autoDeploy) {
+            cliLogger.info('\n🚀 Deployment Mode: Agents will create REAL artifacts in ServiceNow');
+          } else {
+            cliLogger.info('\n📋 Planning Mode: Analysis and recommendations only');
+          }
+          cliLogger.info(`\n💾 Session ID for monitoring: ${sessionId}`);
+        } else {
+          // Non-verbose mode - just show the essential info
+          cliLogger.info('\n📋 Manual Claude Code execution required');
+          cliLogger.info('💡 Run with --verbose to see the full orchestration prompt');
+          
+          if (xmlFlowResult) {
+            cliLogger.info(`📁 XML generated: ${xmlFlowResult.filePath}`);
+          }
+        }
+      }
+      
+    } catch (error) {
+      cliLogger.error('❌ Failed to execute Queen Agent orchestration:', error instanceof Error ? error.message : String(error));
+      
+      // Store error in memory for learning
+      memorySystem.storeLearning(`error_${sessionId}`, {
+        error: error instanceof Error ? error.message : String(error),
+        failed_at: new Date().toISOString()
+      });
+    }
+  });
+
+
+// Helper function to execute Claude Code directly
+async function executeClaudeCode(prompt: string): Promise<boolean> {
+  cliLogger.info('🤖 Preparing Claude Code agent orchestration...');
+  
+  try {
+    // Check if Claude CLI is available
+    const { execSync } = require('child_process');
+    try {
+      execSync('which claude', { stdio: 'ignore' });
+    } catch {
+      cliLogger.warn('⚠️  Claude Code CLI not found in PATH');
+      cliLogger.info('📋 Please install Claude Desktop or copy the prompt manually');
+      return false;
+    }
+    
+    
+    // Check for MCP config
+    const mcpConfigPath = join(process.cwd(), '.mcp.json');
+    const hasMcpConfig = existsSync(mcpConfigPath);
+    
+    // Auto-start MCP servers if they're not running
+    if (hasMcpConfig) {
+      cliLogger.info('🔧 Checking MCP server status...');
+      
+      try {
+        const { MCPServerManager } = await import('./utils/mcp-server-manager.js');
+        const manager = new MCPServerManager();
+        await manager.initialize();
+        
+        const systemStatus = manager.getSystemStatus();
+        
+        if (systemStatus.running === 0) {
+          cliLogger.info('🚀 Starting MCP servers automatically for swarm operation...');
+          await manager.startAllServers();
+          
+          const newStatus = manager.getSystemStatus();
+          cliLogger.info(`✅ Started ${newStatus.running}/${newStatus.total} MCP servers`);
+        } else if (systemStatus.running < systemStatus.total) {
+          cliLogger.info(`⚠️  Only ${systemStatus.running}/${systemStatus.total} MCP servers running`);
+          cliLogger.info('🔄 Starting remaining servers...');
+          await manager.startAllServers();
+          
+          const newStatus = manager.getSystemStatus();
+          cliLogger.info(`✅ All ${newStatus.running}/${newStatus.total} MCP servers running`);
+        } else {
+          cliLogger.info(`✅ All ${systemStatus.running} MCP servers already running`);
+        }
+      } catch (error) {
+        cliLogger.warn('⚠️  Could not auto-start MCP servers:', error instanceof Error ? error.message : error);
+        cliLogger.info('💡 You may need to run "npm run mcp:start" manually');
+      }
+    }
+    
+    // Launch Claude Code with MCP config and skip permissions to avoid raw mode issues
+    const claudeArgs = hasMcpConfig 
+      ? ['--mcp-config', '.mcp.json', '.', '--dangerously-skip-permissions']
+      : ['--dangerously-skip-permissions'];
+    
+    cliLogger.info('🚀 Launching Claude Code automatically...');
+    if (hasMcpConfig) {
+      cliLogger.info('🔧 Starting Claude Code with ServiceNow MCP servers...');
+    }
+    
+    // Start Claude Code process in interactive mode with stdin piping
+    const claudeProcess = spawn('claude', claudeArgs, {
+      stdio: ['pipe', 'inherit', 'inherit'], // pipe stdin, inherit stdout/stderr
+      cwd: process.cwd(),
+      env: { ...process.env }
+    });
+    
+    // Send the prompt via stdin
+    cliLogger.info('📝 Sending orchestration prompt to Claude Code...');
+    cliLogger.info('🚀 Claude Code interface opening...\n');
+    
+    // Write prompt to stdin
+    claudeProcess.stdin.write(prompt);
+    claudeProcess.stdin.end();
+    
+    // Set up process monitoring
+    return new Promise((resolve) => {
+      claudeProcess.on('close', async (code) => {
+        
+        if (code === 0) {
+          cliLogger.info('\n✅ Claude Code session completed successfully!');
+          resolve(true);
+        } else {
+          cliLogger.warn(`\n⚠️  Claude Code session ended with code: ${code}`);
+          resolve(false);
+        }
+      });
+      
+      claudeProcess.on('error', (error) => {
+        cliLogger.error(`❌ Failed to start Claude Code: ${error.message}`);
+        resolve(false);
+      });
+      
+      // Set timeout (configurable via environment variable)
+      const timeoutMinutes = parseInt(process.env.SNOW_FLOW_TIMEOUT_MINUTES || '0');
+      if (timeoutMinutes > 0) {
+        setTimeout(() => {
+          cliLogger.warn(`⏱️  Claude Code session timeout (${timeoutMinutes} minutes), terminating...`);
+          claudeProcess.kill('SIGTERM');
+          resolve(false);
+        }, timeoutMinutes * 60 * 1000);
+      }
+    });
+    
+  } catch (error) {
+    cliLogger.error('❌ Error launching Claude Code:', error instanceof Error ? error.message : String(error));
+    cliLogger.info('📋 Claude Code prompt generated - please copy and paste manually');
+    return false;
+  }
+}
+
+// Real-time monitoring dashboard for Claude Code process
+function startMonitoringDashboard(claudeProcess: ChildProcess): NodeJS.Timeout {
+  let iterations = 0;
+  const startTime = Date.now();
+  
+  // Show initial dashboard only once
+  cliLogger.info(`┌─────────────────────────────────────────────────────────────┐`);
+  cliLogger.info(`│               🚀 Snow-Flow Dashboard v${VERSION}            │`);
+  cliLogger.info(`├─────────────────────────────────────────────────────────────┤`);
+  cliLogger.info(`│ 🤖 Claude Code Status:  ✅ Starting                          │`);
+  cliLogger.info(`│ 📊 Process ID:          ${claudeProcess.pid || 'N/A'}        │`);
+  cliLogger.info(`│ ⏱️  Session Time:        00:00                               │`);
+  cliLogger.info(`│ 🔄 Monitoring Cycles:    0                                   │`);
+  cliLogger.info('└─────────────────────────────────────────────────────────────┘');
+  
+  // Silent monitoring - only log to file or memory, don't interfere with Claude Code UI
+  const monitoringInterval = setInterval(() => {
+    iterations++;
+    const uptime = Math.floor((Date.now() - startTime) / 1000);
+    
+    // Silent monitoring - check files but don't output to console
+    try {
+      const serviceNowDir = join(process.cwd(), 'servicenow');
+      fs.readdir(serviceNowDir).then(files => {
+        // Files are being generated - could log to file if needed
+        // console.log(`\n📁 Generated Files: ${files.length} artifacts in servicenow/`);
+      }).catch(() => {
+        // Directory doesn't exist yet, that's normal
+      });
+    } catch (error) {
+      // Ignore errors
+    }
+    
+  }, 5000); // Check every 5 seconds silently
+  
+  return monitoringInterval;
+}
+
+async function executeWithClaude(claudeCommand: string, prompt: string, resolve: (value: boolean) => void): Promise<void> {
+  cliLogger.info('🚀 Starting Claude Code execution...');
+  
+  // Write prompt to temporary file for large prompts
+  const tempFile = join(process.cwd(), '.snow-flow-prompt.tmp');
+  await fs.writeFile(tempFile, prompt);
+  
+  // Check if .mcp.json exists in current directory
+  const mcpConfigPath = join(process.cwd(), '.mcp.json');
+  let hasMcpConfig = false;
+  try {
+    await fs.access(mcpConfigPath);
+    hasMcpConfig = true;
+    cliLogger.info('✅ Found MCP configuration in current directory');
+  } catch {
+    cliLogger.warn('⚠️  No MCP configuration found. Run "snow-flow init" to set up MCP servers');
+  }
+  
+  const claudeArgs = hasMcpConfig 
+    ? ['--mcp-config', '.mcp.json', '.', '--dangerously-skip-permissions']
+    : ['--dangerously-skip-permissions'];
+  
+  if (hasMcpConfig) {
+    cliLogger.info('🔧 Starting Claude Code with ServiceNow MCP servers...');
+  }
+  
+  // Start Claude Code process in interactive mode
+  const claudeProcess = spawn(claudeCommand, claudeArgs, {
+    stdio: ['pipe', 'inherit', 'inherit'], // inherit stdout/stderr for interactive mode
+    cwd: process.cwd()
+  });
+  
+  // Send the prompt via stdin
+  cliLogger.info('📝 Sending orchestration prompt to Claude Code...');
+  cliLogger.info('🚀 Claude Code interactive interface opening...\n');
+  
+  claudeProcess.stdin.write(prompt);
+  claudeProcess.stdin.end();
+  
+  // Start silent monitoring dashboard (doesn't interfere with Claude Code UI)
+  const monitoringInterval = startMonitoringDashboard(claudeProcess);
+  
+  claudeProcess.on('close', (code) => {
+    clearInterval(monitoringInterval);
+    if (code === 0) {
+      cliLogger.info('\n✅ Claude Code session completed successfully!');
+      resolve(true);
+    } else {
+      cliLogger.warn(`\n❌ Claude Code session ended with code: ${code}`);
+      resolve(false);
+    }
+  });
+  
+  claudeProcess.on('error', (error) => {
+    clearInterval(monitoringInterval);
+    cliLogger.error(`❌ Failed to start Claude Code: ${error.message}`);
+    resolve(false);
+  });
+  
+  // Set timeout for Claude Code execution (configurable via environment variable)
+  const timeoutMinutes = process.env.SNOW_FLOW_TIMEOUT_MINUTES ? parseInt(process.env.SNOW_FLOW_TIMEOUT_MINUTES) : 60;
+  const timeoutMs = timeoutMinutes * 60 * 1000;
+  
+  cliLogger.info(`⏱️  Claude Code timeout set to ${timeoutMinutes} minutes (configure with SNOW_FLOW_TIMEOUT_MINUTES=0 for no timeout)`);
+  
+  let timeout: NodeJS.Timeout | null = null;
+  
+  // Only set timeout if not disabled (0 = no timeout)
+  if (timeoutMinutes > 0) {
+    timeout = setTimeout(() => {
+      clearInterval(monitoringInterval);
+      cliLogger.warn(`⏱️  Claude Code session timeout (${timeoutMinutes} minutes), terminating...`);
+      claudeProcess.kill('SIGTERM');
+      
+      // Force kill if it doesn't respond
+      setTimeout(() => {
+        claudeProcess.kill('SIGKILL');
+      }, 2000);
+      
+      resolve(false);
+    }, timeoutMs);
+  }
+  
+  claudeProcess.on('close', () => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  });
+}
+
+// Helper function to build Queen Agent orchestration prompt
+function buildQueenAgentPrompt(objective: string, taskAnalysis: TaskAnalysis, options: any, isAuthenticated: boolean = false, sessionId: string, isFlowDesignerTask: boolean = false): string {
+  // Check if intelligent features are enabled
+  const hasIntelligentFeatures = options.autoPermissions || options.smartDiscovery || 
+    options.liveTesting || options.autoDeploy || options.autoRollback || 
+    options.sharedMemory || options.progressMonitoring;
+  
+  // Calculate actual autonomous system states (with override logic)
+  const noAutonomousAll = options.autonomousAll === false;
+  const forceAutonomousAll = options.autonomousAll === true;
+  
+  const autonomousDocActive = noAutonomousAll ? false : 
+    forceAutonomousAll ? true : 
+    options.autonomousDocumentation !== false;
+  
+  const autonomousCostActive = noAutonomousAll ? false : 
+    forceAutonomousAll ? true : 
+    options.autonomousCostOptimization !== false;
+  
+  const autonomousComplianceActive = noAutonomousAll ? false : 
+    forceAutonomousAll ? true : 
+    options.autonomousCompliance !== false;
+  
+  const autonomousHealingActive = noAutonomousAll ? false : 
+    forceAutonomousAll ? true : 
+    options.autonomousHealing !== false;
+  
+  const hasAutonomousSystems = autonomousDocActive || autonomousCostActive || 
+    autonomousComplianceActive || autonomousHealingActive;
+
+  const prompt = `# 👑 Snow-Flow Queen Agent Orchestration
+
+## 🎯 Mission Brief
+You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mission is to orchestrate a swarm of specialized agents to complete the following ServiceNow development objective:
+
+**Objective**: ${objective}
+**Session ID**: ${sessionId}
+
+## 🧠 Task Analysis Summary
+- **Task Type**: ${taskAnalysis.taskType}
+- **Complexity**: ${taskAnalysis.complexity}
+- **Primary Agent Required**: ${taskAnalysis.primaryAgent}
+- **Supporting Agents**: ${taskAnalysis.supportingAgents.join(', ')}
+- **Estimated Total Agents**: ${taskAnalysis.estimatedAgentCount}
+- **ServiceNow Artifacts**: ${taskAnalysis.serviceNowArtifacts.join(', ')}
+
+## ⚡ CRITICAL: Task Intent Analysis
+**BEFORE PROCEEDING**, analyze the user's ACTUAL intent:
+
+1. **Data Generation Request?** (e.g., "create 5000 incidents", "generate test data")
+   → Focus on CREATING DATA, not building systems
+   → Use simple scripts or bulk operations to generate the data
+   → Skip complex architectures unless explicitly asked
+
+2. **System Building Request?** (e.g., "build a widget", "create an ML system")
+   → Follow full development workflow
+   → Build proper architecture and components
+
+3. **Simple Operation Request?** (e.g., "update field X", "delete records")
+   → Execute the operation directly
+   → Skip unnecessary complexity
+
+**For this objective**: Analyze if the user wants data generation, system building, or a simple operation.
+
+${isFlowDesignerTask ? `## 🔧 Flow Designer Task Detected - Using ENHANCED XML-First Approach!
+🚀 **FULLY AUTOMATED FLOW DEPLOYMENT v2.0** - ALL features working correctly!
+
+**MANDATORY: Use this exact approach for Flow Designer tasks:**
+
+\`\`\`javascript
+// ✅ ENHANCED v2.0: Complete flow generation with ALL features
+await snow_create_flow({
+  instruction: "your natural language flow description", 
+  deploy_immediately: true,  // 🔥 Automatically deploys to ServiceNow!
+  return_metadata: true     // 📊 Returns complete deployment metadata
+});
+\`\`\`
+
+🎯 **What this does automatically (ENHANCED v1.3.28+):**
+- ✅ Uses CompleteFlowXMLGenerator for PROPER flow structure
+- ✅ Generates with v2 tables (sys_hub_action_instance_v2, sys_hub_trigger_instance_v2)
+- ✅ Applies Base64+gzip encoding for action values
+- ✅ Includes comprehensive label_cache structure
+- ✅ Imports XML to ServiceNow as remote update set
+- ✅ Automatic tool name resolution with MCPToolRegistry
+- ✅ Complete metadata extraction (sys_id, URLs, endpoints)
+- ✅ Performance _analysis and recommendations
+- ✅ 100% of requested features deploy correctly!
+
+🚫 **FORBIDDEN APPROACHES:**
+- ❌ DO NOT use old API-only approach without XML generation
+- ❌ DO NOT use manual \`snow-flow deploy-xml\` commands 
+- ❌ DO NOT generate XML without auto-deployment
+- ❌ DO NOT use v1 tables (they create empty flows!)
+
+💡 **Why Enhanced XML-First v2.0?**
+- Fixes ALL critical issues from beta testing
+- Flows deploy with 100% of requested features working
+- Complete metadata always returned (no more null sys_id)
+- Tool names resolve correctly across all MCP providers
+- Zero chance of empty flows or missing features!
+
+` : ''}
+- **Recommended Team**: ${getTeamRecommendation(taskAnalysis.taskType)}
+
+## 📊 Table Discovery Intelligence
+
+The Queen Agent will automatically discover and validate table schemas based on the objective. This ensures agents use correct field names and table structures.
+
+**Table Detection Examples:**
+- "create widget for incident records" → Discovers: incident, sys_user, sys_user_group
+- "build approval flow for u_equipment_request" → Discovers: u_equipment_request, sys_user, sysapproval_approver
+- "portal showing catalog items" → Discovers: sc_cat_item, sc_category, sc_request
+- "dashboard with CMDB assets" → Discovers: cmdb_ci, cmdb_rel_ci, sys_user
+- "report on problem tickets" → Discovers: problem, incident, sys_user
+
+**Discovery Process:**
+1. Extracts table names from objective (standard tables, u_ custom tables, explicit mentions)
+2. Discovers actual table schemas with field names, types, and relationships
+3. Stores schemas in memory for all agents to use
+4. Agents MUST use exact field names from schemas (e.g., 'short_description' not 'desc')
+
+## 👑 Your Queen Agent Responsibilities
+
+## 📊 Data Generation Specific Instructions
+If the task is identified as DATA GENERATION (e.g., "create 5000 incidents"):
+
+1. **DO NOT** build complex export/import systems
+2. **DO NOT** create APIs, UI Actions, or workflows
+3. **DO** focus on:
+   - Creating a simple script to generate the data
+   - Using ServiceNow's REST API or direct table operations
+   - Ensuring realistic data distribution for ML training
+   - Adding variety in categories, priorities, descriptions, etc.
+
+**Example approach for "create 5000 incidents":**
+\`\`\`javascript
+// Simple batch creation script
+for (let i = 0; i < 5000; i += 100) {
+  // Create 100 incidents at a time to avoid timeouts
+  const batch = generateRealisticIncidentBatch(100);
+  await createIncidentsBatch(batch);
+}
+\`\`\`
+
+### 1. CRITICAL: Initialize Memory FIRST (Before Everything!)
+**THIS MUST BE YOUR VERY FIRST ACTION - Initialize the swarm memory session:**
+\`\`\`javascript
+// 🚨 EXECUTE THIS IMMEDIATELY - DO NOT SKIP OR DELAY!
+mcp__snow-flow__memory_usage({
+  key: "swarm_session_${sessionId}",
+  value: JSON.stringify({
+    objective: "${objective}",
+    status: "initializing", 
+    started_at: new Date().toISOString(),
+    queen_agent_id: "queen_${sessionId}",
+    task_analysis: ${JSON.stringify(taskAnalysis, null, 2)},
+    configuration: {
+      strategy: "${options.strategy}",
+      mode: "${options.mode}",
+      max_agents: ${parseInt(options.maxAgents)},
+      parallel_execution: ${options.parallel ? 'true' : 'false'},
+      monitoring_enabled: ${options.monitor ? 'true' : 'false'},
+      auth_required: ${!isAuthenticated}
+    }
+  }),
+  namespace: "swarm_${sessionId}"
+});
+
+// Agent coordination namespace handled automatically by ServiceNow memory system
+\`\`\`
+
+### 2. MANDATORY MCP-FIRST Workflow Steps
+**Execute these steps IN ORDER before spawning agents:**
+
+\`\`\`javascript
+// Step 2.1: Validate ServiceNow authentication
+const authCheck = await mcp__servicenow-intelligent__snow_validate_live_connection({
+  test_level: "permissions",
+  include_performance: false
+});
+
+if (!authCheck.connection_status === "success") {
+  throw new Error("Authentication failed! Run: snow-flow auth login");
+}
+
+// Step 2.2: Check for existing artifacts (DRY principle)
+const existingArtifacts = await mcp__servicenow-intelligent__snow_comprehensive_search({
+  query: "${objective}",
+  include_inactive: false
+});
+
+// Store discovery results in memory for agents
+await mcp__snow-flow__memory_usage({
+  key: "existing_artifacts_${sessionId}",
+  value: JSON.stringify(existingArtifacts),
+  namespace: "swarm_${sessionId}"
+});
+
+// Step 2.3: Create isolated Update Set for this objective
+const updateSetName = "Snow-Flow: ${objective.substring(0, 50)}... - ${new Date().toISOString().split('T')[0]}";
+const updateSet = await mcp__servicenow-update-set__snow_update_set_create({
+  name: updateSetName,
+  description: "Automated creation for: ${objective}\\n\\nSession: ${sessionId}",
+  auto_switch: true
+});
+
+// Store Update Set info in memory
+await mcp__snow-flow__memory_usage({
+  key: "update_set_${sessionId}",
+  value: JSON.stringify(updateSet),
+  namespace: "swarm_${sessionId}"
+});
+
+// Step 2.4: Discover tables mentioned in objective
+// Extract potential table names from the objective
+const tablePatterns = [
+  /\b(incident|problem|change_request|sc_request|sc_req_item|task|cmdb_ci|sys_user|sys_user_group)\b/gi,
+  /\b(u_\w+)\b/g, // Custom tables starting with u_
+  /\b(\w+_table)\b/gi, // Tables ending with _table
+  /\bfrom\s+(\w+)\b/gi, // SQL-like "from table_name"
+  /\btable[:\s]+(\w+)\b/gi, // "table: xyz" or "table xyz"
+  /\b(\w+)\s+records?\b/gi, // "xyz records"
+];
+
+const detectedTables = new Set();
+// Always include common tables for context
+['incident', 'sc_request', 'sys_user'].forEach(t => detectedTables.add(t));
+
+// Search for tables in objective
+for (const pattern of tablePatterns) {
+  const matches = "${objective}".matchAll(pattern);
+  for (const match of matches) {
+    if (match[1]) {
+      detectedTables.add(match[1].toLowerCase());
+    }
+  }
+}
+
+// Also check for common data needs based on objective type
+if ("${objective}".toLowerCase().includes('catalog')) {
+  detectedTables.add('sc_cat_item');
+  detectedTables.add('sc_category');
+}
+if ("${objective}".toLowerCase().includes('user')) {
+  detectedTables.add('sys_user');
+  detectedTables.add('sys_user_group');
+}
+if ("${objective}".toLowerCase().includes('cmdb') || "${objective}".toLowerCase().includes('asset')) {
+  detectedTables.add('cmdb_ci');
+}
+if ("${objective}".toLowerCase().includes('knowledge')) {
+  detectedTables.add('kb_knowledge');
+}
+
+cliLogger.info(\`🔍 Detected tables to discover: \${Array.from(detectedTables).join(', ')}\`);
+
+// Discover schemas for all detected tables
+const tableSchemas = {};
+for (const tableName of detectedTables) {
+  try {
+    const schema = await mcp__servicenow-platform-development__snow_table_schema_discovery({
+      tableName: tableName,
+      includeRelated: true,
+      includeIndexes: false,
+      maxDepth: 1 // Don't go too deep to avoid timeout
+    });
+    
+    if (schema && schema.fields) {
+      tableSchemas[tableName] = {
+        name: tableName,
+        label: schema.label || tableName,
+        fields: schema.fields,
+        field_count: schema.fields.length,
+        key_fields: schema.fields.filter(f => f.primary || f.reference).map(f => f.name)
+      };
+      cliLogger.info(\`✅ Discovered table '\${tableName}' with \${schema.fields.length} fields\`);
+    }
+  } catch (e) {
+    cliLogger.warn(\`⚠️ Table '\${tableName}' not found or inaccessible\`);
+  }
+}
+
+// Store discovered table schemas in memory
+await mcp__snow-flow__memory_usage({
+  action: "store",
+  key: "table_schemas_${sessionId}",
+  value: JSON.stringify({
+    discovered_at: new Date().toISOString(),
+    objective: "${objective}",
+    tables: tableSchemas,
+    table_names: Object.keys(tableSchemas)
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+
+### 3. Create Master Task List
+After completing MCP-FIRST steps, create task breakdown:
+\`\`\`javascript
+TodoWrite([
+  {
+    id: "mcp_workflow_complete",
+    content: "✅ MCP-FIRST workflow: Auth, Discovery, Update Set, Tables",
+    status: "completed",
+    priority: "high"
+  },
+  {
+    id: "analyze_requirements",
+    content: "Analyze user requirements: ${objective}",
+    status: "in_progress",
+    priority: "high"
+  },
+  {
+    id: "spawn_agents",
+    content: "Spawn ${taskAnalysis.estimatedAgentCount} specialized agents",
+    status: "pending",
+    priority: "high"
+  },
+  {
+    id: "coordinate_development",
+    content: "Coordinate agent activities for ${taskAnalysis.taskType}",
+    status: "pending",
+    priority: "high"
+  },
+  {
+    id: "validate_solution",
+    content: "Validate and test the complete solution",
+    status: "pending",
+    priority: "medium"
+  }
+]);
+\`\`\`
+
+### 4. Intelligent Agent Spawning with Dependency-Based Batching
+
+⚡ **CRITICAL: Spawn agents in SMART BATCHES based on dependencies!**
+
+Based on the task analysis, we need to spawn ${taskAnalysis.estimatedAgentCount} agents.
+
+${getAgentSpawnStrategy(taskAnalysis)}
+
+### 5. Memory Coordination Pattern
+All agents MUST use this memory coordination pattern:
+
+\`\`\`javascript
+// Agent initialization
+const session = Memory.get("swarm_session_${sessionId}");
+const agentId = \`agent_\${agentType}_${sessionId}\`;
+
+// Agent stores progress
+Memory.store(\`\${agentId}_progress\`, {
+  status: "working",
+  current_task: "description of current work",
+  completion_percentage: 45,
+  last_update: new Date().toISOString()
+});
+
+// Agent reads other agent's work
+const primaryWork = Memory.get("agent_${taskAnalysis.primaryAgent}_output");
+
+// Agent signals completion
+Memory.store(\`\${agentId}_complete\`, {
+  completed_at: new Date().toISOString(),
+  outputs: { /* agent deliverables */ },
+  artifacts_created: [ /* list of created artifacts */ ]
+});
+\`\`\`
+
+## 🧠 Intelligent Features Configuration
+${hasIntelligentFeatures ? `✅ **INTELLIGENT MODE ACTIVE** - The following features are enabled:
+
+- **🔐 Auto Permissions**: ${options.autoPermissions ? '✅ Will escalate permissions automatically' : '❌ Manual permission handling'}
+- **🔍 Smart Discovery**: ${options.smartDiscovery ? '✅ Will discover and reuse existing artifacts' : '❌ Create all new artifacts'}
+- **🧪 Live Testing**: ${options.liveTesting ? '✅ Will test in real ServiceNow instance' : '❌ Local testing only'}
+- **🚀 Auto Deploy**: ${options.autoDeploy ? '⚠️ WILL DEPLOY TO SERVICENOW AUTOMATICALLY' : '✅ Planning mode - no deployment'}
+- **🔄 Auto Rollback**: ${options.autoRollback ? '✅ Will rollback on any failures' : '❌ No automatic rollback'}
+- **💾 Shared Memory**: ${options.sharedMemory ? '✅ Agents share context via Memory' : '❌ Isolated agent execution'}
+- **📊 Progress Monitoring**: ${options.progressMonitoring ? '✅ Real-time progress tracking' : '❌ No progress monitoring'}` : '❌ **STANDARD MODE** - Use manual coordination patterns'}
+
+## 🎯 ServiceNow Execution Strategy
+
+### 🚀 MANDATORY: Live ServiceNow Development First!
+
+**CRITICAL RULE**: All agents MUST attempt to use ServiceNow MCP tools first, regardless of authentication status.
+
+${hasIntelligentFeatures ? `#### 🧠 Intelligent Orchestration Available
+Use the unified orchestration tool for complete automation:
+
+\`\`\`javascript
+// Queen Agent uses this for intelligent orchestration
+snow_orchestrate_development({
+  objective: "${objective}",
+  auto_permissions: ${options.autoPermissions},
+  smart_discovery: ${options.smartDiscovery},
+  live_testing: ${options.liveTesting},
+  auto_deploy: ${options.autoDeploy},
+  auto_rollback: ${options.autoRollback},
+  shared_memory: ${options.sharedMemory},
+  progress_monitoring: ${options.progressMonitoring}
+});
+\`\`\`
+
+## 🧠 REVOLUTIONARY: Intelligent Gap Analysis Engine (v1.1.88)
+**AUTOMATIC BEYOND-MCP CONFIGURATION DETECTION**
+
+The Queen Agent now includes the revolutionary **Intelligent Gap Analysis Engine** that automatically detects and resolves ALL ServiceNow configurations needed beyond standard MCP tools.
+
+**What Gap Analysis Does:**
+- **🔍 Analyzes Requirements**: AI-powered parsing of objectives to identify 60+ types of ServiceNow configurations
+- **📊 MCP Coverage Analysis**: Maps what current MCP tools can handle vs manual setup requirements
+- **🤖 Auto-Resolution Engine**: Attempts automatic configuration via ServiceNow APIs for safe operations
+- **📚 Manual Guide Generation**: Creates detailed step-by-step guides with role requirements and risk assessment
+- **🛡️ Risk Assessment**: Evaluates complexity and safety of each configuration
+- **🌍 Environment Awareness**: Provides dev/test/prod specific guidance and warnings
+
+**60+ Configuration Types Covered:**
+- **🔐 Authentication**: LDAP, SAML, OAuth providers, SSO, MFA configurations
+- **🗄️ Database**: Indexes, views, partitioning, performance analytics, system properties
+- **🧭 Navigation**: Application menus, modules, form layouts, UI actions, policies
+- **📧 Integration**: Email templates, web services, import sets, transform maps
+- **🔄 Workflow**: Activities, transitions, SLA definitions, escalation rules
+- **🛡️ Security**: ACL rules, data policies, audit rules, compliance configurations
+- **📊 Reporting**: Custom reports, dashboards, KPIs, performance analytics
+
+**Example Output:**
+\`\`\`
+🧠 Step 4: Running Intelligent Gap Analysis...
+📊 Gap Analysis Complete:
+  • Total Requirements: 12
+  • MCP Coverage: 67%
+  • Automated: 6 configurations  
+  • Manual Work: 4 items
+
+✅ Automatically Configured:
+  • System property: glide.ui.incident_management created
+  • Navigation module: Incident Management added to Service Desk
+  • Email template: incident_notification configured
+  • Database index: incident.priority_state for performance
+
+📋 Manual Configuration Required:
+  • LDAP authentication setup (high-risk operation)
+  • SSO configuration with Active Directory
+  
+📚 Detailed Manual Guides Available:
+  📖 Configure LDAP Authentication - 25 minutes
+     Risk: high | Roles: security_admin, admin
+\`\`\`
+
+**The Gap Analysis Engine automatically runs as part of Queen Agent execution - no additional commands needed!**
+
+` : ''}
+
+#### ServiceNow MCP Tools (ALWAYS TRY THESE FIRST!)
+${isAuthenticated ? '✅ Authentication detected - full deployment capabilities' : '⚠️ No authentication detected - MCP tools will provide specific instructions if auth needed'}
+
+Your agents MUST use these MCP tools IN THIS ORDER:
+
+🔍 **PRE-FLIGHT CHECKS** (Always do first!):
+1. \`snow_find_artifact\` with a simple query to test authentication
+2. If auth fails, the tool provides specific instructions
+3. Continue with appropriate strategy based on auth status
+
+🎯 **Universal Query Tool** - Use for ALL table queries
+- \`snow_query_table\` - Replaces all table-specific query tools with intelligent optimization:
+  - **Count-only** (default): \`{table: "incident", query: "state!=7"}\` → 99.9% memory savings
+  - **Specific fields**: \`{table: "sc_request", fields: ["number", "state"]}\` → Only needed data
+  - **Group by**: \`{table: "problem", group_by: "category", order_by: "-priority"}\` → Analytics
+  - **Full content**: \`{table: "change_request", include_content: true}\` → When all data needed
+  - Works with ANY table: incident, sc_request, problem, cmdb_ci, even u_custom_tables!
+
+📦 **CORE DEVELOPMENT TOOLS**:
+1. **Deployment Tools** (servicenow-deployment-mcp)
+   - \`snow_deploy\` - Unified deployment for all artifact types
+   - \`snow_preview_widget\` - Preview widgets before deployment
+   - \`snow_widget_test\` - Test widget functionality
+
+2. **Discovery Tools** (servicenow-intelligent-mcp)
+   - \`snow_find_artifact\` - Natural language artifact search
+   - \`snow_catalog_item_search\` - Find catalog items with fuzzy matching
+   - \`snow_get_by_sysid\` - Direct sys_id lookup
+
+3. **Update Set Management** (servicenow-update-set-mcp)
+   - \`snow_update_set_create\` - Create new update sets
+   - \`snow_update_set_add_artifact\` - Track artifacts
+   - \`snow_update_set_complete\` - Complete update sets
+
+🚀 **14 ADVANCED SERVICENOW INTELLIGENCE TOOLS** - NEW v1.4.9!
+
+**Performance & Optimization (Features 1-4)**:
+4. **Smart Batch API Operations** (\`snow_batch_api\`)
+   - 80% API call reduction through intelligent batching
+   - Parallel execution with transaction support
+   - Query optimization and result caching
+   - Real-time performance monitoring
+
+5. **Table Relationship Mapping** (\`snow_get_table_relationships\`)
+   - Deep relationship discovery across table hierarchies
+   - Visual relationship diagrams (Mermaid format)
+   - Impact analysis for schema changes
+   - Performance optimization recommendations
+
+6. **Query Performance Analyzer** (\`snow_analyze_query\`)
+   - Query execution analysis with bottleneck detection
+   - Index recommendations for performance optimization
+   - Alternative query suggestions with risk assessment
+   - Execution time prediction
+
+7. **Field Usage Intelligence** (\`snow_analyze_field_usage\`)
+   - Comprehensive field usage analysis across all ServiceNow components
+   - Unused field detection with deprecation recommendations
+   - Technical debt scoring and optimization opportunities
+   - Cross-component impact analysis
+
+**Migration & Architecture (Features 5-7)**:
+8. **Migration Helper** (\`snow_create_migration_plan\`)
+   - Automated migration planning with risk assessment
+   - Data transformation scripts generation
+   - Performance impact estimation and rollback strategy creation
+
+9. **Deep Table Analysis** (\`snow_analyze_table_deep\`)
+   - Multi-dimensional table analysis (structure, data quality, performance)
+   - Security and compliance assessment
+   - Usage pattern analysis and optimization recommendations
+
+10. **Code Pattern Detector** (\`snow_detect_code_patterns\`)
+    - Advanced pattern recognition across all script types
+    - Performance anti-pattern detection and security vulnerability scanning
+    - Maintainability scoring with refactoring suggestions
+
+**AI-Powered Intelligence (Features 8-10)**:
+11. **Predictive Impact Analysis** (\`snow_predict_change_impact\`)
+    - AI-powered change impact prediction with confidence scoring
+    - Risk assessment and dependency chain analysis
+    - Rollback requirement prediction
+
+12. **Auto Documentation Generator** (\`snow_generate_documentation\`)
+    - Intelligent documentation generation from code and configuration
+    - Multiple output formats (Markdown, HTML, PDF)
+    - Relationship diagrams and architecture documentation
+
+13. **Intelligent Refactoring** (\`snow_refactor_code\`)
+    - AI-driven code refactoring with performance optimization
+    - Modern JavaScript patterns and best practices
+    - Security hardening and error handling improvements
+
+**Process Mining & Workflow (Features 11-14)**:
+14. **Process Mining Engine** (\`snow_discover_process\`)
+    - Real process discovery from ServiceNow event logs
+    - Process variant analysis and bottleneck identification
+    - Compliance checking with ROI calculation
+
+15. **Workflow Reality Analyzer** (\`snow_analyze_workflow_execution\`)
+    - Real workflow execution analysis vs. designed processes
+    - Performance bottleneck identification and SLA compliance monitoring
+
+16. **Cross Table Process Discovery** (\`snow_discover_cross_table_process\`)
+    - Multi-table process flow discovery
+    - Data lineage and transformation tracking
+    - Integration point analysis
+
+17. **Real Time Process Monitoring** (\`snow_monitor_process\`)
+    - Live process monitoring with real-time alerts
+    - Anomaly detection using machine learning
+    - Performance trend analysis and predictive failure detection
+
+🧠 **MACHINE LEARNING & NEURAL NETWORKS (Features 18-25)**:
+18. **Incident Classification Neural Network** (\`ml_train_incident_classifier\`)
+    - Train LSTM neural networks on historical incident data
+    - 95%+ accuracy for category, priority, and assignment prediction
+    - Text embedding and multi-class classification
+
+19. **Incident Classification** (\`ml_classify_incident\`)
+    - Use trained neural network to classify incidents
+    - Real-time predictions with confidence scores
+    - Top-3 category recommendations
+
+20. **Change Risk Prediction** (\`ml_train_change_risk\`)
+    - Train neural networks for change risk assessment
+    - Analyze historical success/failure patterns
+    - Feature importance analysis
+
+21. **Risk Prediction** (\`ml_predict_change_risk\`)
+    - Predict implementation risk for changes
+    - Confidence scoring and recommendations
+    - Identify high-risk changes before deployment
+
+22. **Incident Volume Forecasting** (\`ml_forecast_incidents\`)
+    - LSTM time series forecasting
+    - Predict daily/weekly incident volumes
+    - Category-specific predictions
+
+23. **Anomaly Detection** (\`ml_train_anomaly_detector\`)
+    - Autoencoder neural networks for anomaly detection
+    - Detect unusual patterns in metrics
+    - 95th percentile threshold calculation
+
+24. **Detect Anomalies** (\`ml_detect_anomalies\`)
+    - Real-time anomaly detection
+    - Pattern deviation analysis
+    - Alert on potential issues
+
+25. **ML Model Status** (\`ml_model_status\`)
+    - Check trained model availability
+    - Model performance metrics
+    - TensorFlow.js backend info
+
+⚠️ **ML LICENSING REQUIREMENTS**:
+- **Performance Analytics (PA)**: Required for KPI forecasting and analytics
+- **Predictive Intelligence (PI)**: Required for clustering and similarity
+- **Custom Neural Networks**: Always available via TensorFlow.js
+- **No Mock Data**: Real errors when licenses unavailable
+
+🎯 **WHEN TO USE WHICH ML APPROACH**:
+
+**PREFERRED: ServiceNow Native ML (BEST RESULTS but requires licenses):**
+- 🏆 **Predictive Intelligence (PI)**: 
+  - Incident classification & categorization
+  - Similar incident matching
+  - Change risk prediction
+  - Solution recommendations
+  - Knowledge article suggestions
+- 🏆 **Performance Analytics (PA)**: 
+  - KPI forecasting
+  - Trend analysis
+  - Anomaly detection in metrics
+- 🏆 **Agent Intelligence**: 
+  - Intelligent work assignment
+  - Workload balancing
+
+**FALLBACK: TensorFlow.js Neural Networks (NO LICENSE REQUIRED):**
+- ✅ Use when PI/PA not available
+- ✅ Custom pattern recognition
+- ✅ Time series forecasting (if PA not available)
+- ✅ Basic incident classification (if PI not available)
+- ✅ Change risk prediction (if PI not available)
+- ✅ Anomaly detection (if PA not available)
+
+**BEST PRACTICE - Try in this order:**
+1. **First**: Check if PI/PA available with ml_performance_analytics or ml_predictive_intelligence
+2. **If available**: Use native ML for superior results (95%+ accuracy)
+3. **If not available**: Fall back to TensorFlow.js (80-85% accuracy)
+4. **Optimal**: Use ml_hybrid_recommendation to combine both when possible
+
+**AGENT INSTRUCTIONS**: Always check for PI/PA first - they give MUCH better results for ServiceNow data!
+
+📋 **ML DECISION TREE - WHICH TOOL TO USE**:
+\`\`\`
+Is it a standard ServiceNow object? (incident/change/problem/request)
+  └─ YES → Do you have PI/PA license?
+      └─ YES → Use Native ML (best choice: 95%+ accuracy)
+      └─ NO → Use TensorFlow.js (fallback: 80-85% accuracy)
+  └─ NO → Is it custom data/table (u_*)?
+      └─ YES → ONLY TensorFlow.js works!
+
+Does it need to run in browser? (real-time, instant feedback)
+  └─ YES → ONLY TensorFlow.js works! (client-side ML)
+
+Is it privacy-sensitive data? (HR, salary, personal)
+  └─ YES → TensorFlow.js (keeps data local)
+
+Must work offline? (mobile, disconnected)
+  └─ YES → TensorFlow.js with local model storage
+
+Need custom patterns not in ServiceNow ML?
+  └─ YES → TensorFlow.js for custom neural networks
+\`\`\`
+
+**UNIQUE TENSORFLOW.JS USE CASES**:
+- 🌐 Client-side predictions in Service Portal widgets
+- 🏢 ML for custom tables (u_employee_performance, u_vendor_rating, etc.)
+- ⚡ Real-time form validation and anomaly detection
+- 📵 Offline mobile app predictions
+- 🔒 Privacy-sensitive calculations that stay in browser
+- 🎯 Custom pattern recognition beyond standard ServiceNow objects
+
+💯 **ZERO MOCK DATA GUARANTEE**: All tools use 100% real ServiceNow APIs - no fake data, ever!
+
+📊 **PERFORMANCE METRICS & BENEFITS**:
+- **80% API Call Reduction** through intelligent batching and optimization
+- **60% Faster Analysis** with parallel processing and caching  
+- **90% Task Automation** of manual ServiceNow analysis workflows
+- **100% Real Data** accuracy - no mocks, placeholders, or demo data
+- **Zero Configuration** - works with any ServiceNow instance
+
+🎯 **USAGE EXAMPLES FOR AGENTS**:
+
+**Performance Analysis:**
+\`\`\`javascript
+// Analyze incident table performance issues
+await snow_analyze_table_deep({
+  table_name: "incident",
+  analysis_scope: ["structure", "data_quality", "performance"],
+  generate_recommendations: true
+});
+
+// Optimize frequently used queries
+await snow_analyze_query({
+  query: "state=1^priority<=2",
+  table: "incident", 
+  analyze_indexes: true,
+  suggest_optimizations: true
+});
+\`\`\`
+
+**Batch Operations:**
+\`\`\`javascript
+// Execute multiple operations with 80% API reduction
+await snow_batch_api({
+  operations: [
+    {operation: "query", table: "incident", query: "state=1"},
+    {operation: "update", table: "incident", sys_id: "xxx", data: {urgency: "1"}}
+  ],
+  parallel: true,
+  transactional: true
+});
+\`\`\`
+
+**Process Mining:**
+\`\`\`javascript
+// Discover real incident management processes
+await snow_discover_process({
+  process_type: "incident_management",
+  analysis_period: "30d",
+  include_variants: true
+});
+
+// Monitor processes in real-time
+await snow_monitor_process({
+  process_name: "incident_resolution",
+  tables_to_monitor: ["incident", "task"],
+  monitoring_duration: "24h"
+});
+\`\`\`
+
+**Intelligence & Automation:**
+\`\`\`javascript
+// AI-powered impact prediction
+await snow_predict_change_impact({
+  change_type: "field_change",
+  target_object: "incident",
+  change_details: {field_changes: ["urgency"]},
+  include_dependencies: true
+});
+
+// Auto-generate documentation
+await snow_generate_documentation({
+  documentation_scope: ["tables", "workflows"],
+  output_format: "markdown",
+  include_diagrams: true
+});
+\`\`\`
+
+🚨 **ERROR RECOVERY PATTERNS**:
+- Auth Error → Document complete solution → Store in Memory → Guide user
+- Permission Error → Try global scope → Document if fails
+- Not Found → Create new → Track in Update Set
+- Any Error → Provide SPECIFIC next steps, not generic messages
+
+⚠️ **403 DEPLOYMENT VERIFICATION BUG**:
+- **IMPORTANT**: 403 errors during deployment verification are often FALSE POSITIVES
+- Widget/artifact deployment usually SUCCEEDS even when verification API returns 403
+- **ALWAYS** check the ServiceNow instance directly before assuming failure
+- If you get 403 on verification, provide the sys_id and direct link to the artifact
+- Tell user: "Deployment likely succeeded despite 403 verification error. Check here: [direct link]"
+
+${options.autoDeploy ? `
+#### ⚠️ AUTO-DEPLOYMENT ACTIVE ⚠️
+- Real artifacts will be created in ServiceNow
+- All changes tracked in Update Sets
+- Rollback available if needed
+` : `
+#### 📋 Planning Mode Active
+- No real artifacts will be created
+- Analysis and recommendations only
+- Use --auto-deploy to enable deployment
+`}
+${!isAuthenticated ? `### ❌ ServiceNow Integration Disabled
+
+#### Planning Mode (Auth Required)
+When authentication is not available, agents will:
+1. Document the COMPLETE solution architecture
+2. Create detailed implementation guides
+3. Store all plans in Memory for future deployment
+4. Provide SPECIFIC instructions: "Run snow-flow auth login"
+
+⚠️ IMPORTANT: This is a FALLBACK mode only!
+Agents must ALWAYS try MCP tools first!` : ''}
+
+## 👑 Queen Agent Coordination Instructions
+
+### 5. Snow-Flow Memory Synchronization Pattern
+Implement continuous memory synchronization for real-time coordination:
+
+\`\`\`javascript
+// Initialize coordination heartbeat (Snow-Flow pattern)
+const coordinationInterval = setInterval(async () => {
+  // Sync agent states across namespace
+  const agentStates = await mcp__snow-flow__memory_search({
+    pattern: "agent_*_progress",
+    namespace: "agents_${sessionId}",
+    limit: 50
+  });
+  
+  // Update swarm coordination state with TTL for freshness
+  await mcp__snow-flow__memory_usage({
+    key: "swarm_coordination_${sessionId}",
+    value: JSON.stringify({
+      timestamp: new Date().toISOString(),
+      active_agents: agentStates.length,
+      completion_status: TodoRead().filter(t => t.status === 'completed').length,
+      memory_sync: true,
+      discovered_artifacts: agentStates.filter(s => s.includes("deployed")).length
+    }),
+    namespace: "swarm_${sessionId}",
+    ttl: 300 // 5 minute TTL for coordination data
+  });
+  
+  // Detect and resolve conflicts between agents
+  if (agentStates.some(s => s.includes("conflict") || s.includes("duplicate"))) {
+    await mcp__snow-flow__memory_usage({
+      key: "conflict_resolution_needed",
+      value: JSON.stringify({
+        agents: agentStates.filter(s => s.includes("conflict")),
+        timestamp: new Date().toISOString()
+      }),
+      namespace: "swarm_${sessionId}"
+    });
+  }
+  
+  // Track deployed artifacts in Update Set automatically
+  const deployedArtifacts = [];
+  for (const state of agentStates) {
+    if (state.includes("deployed") && state.includes("sys_id")) {
+      try {
+        const artifact = JSON.parse(state);
+        if (artifact.sys_id && !artifact.tracked_in_update_set) {
+          deployedArtifacts.push(artifact);
+        }
+      } catch (e) {
+        // Not valid JSON, skip
+      }
+    }
+  }
+  
+  // Add all deployed artifacts to Update Set
+  for (const artifact of deployedArtifacts) {
+    await mcp__servicenow-update-set__snow_update_set_add_artifact({
+      type: artifact.type,
+      sys_id: artifact.sys_id,
+      name: artifact.name
+    });
+    
+    // Mark as tracked
+    artifact.tracked_in_update_set = true;
+    await mcp__snow-flow__memory_usage({
+      key: \`agent_\${artifact.agent}_deployed_\${artifact.sys_id}\`,
+      value: JSON.stringify(artifact),
+      namespace: "agents_${sessionId}"
+    });
+  }
+  
+  // Monitor individual agent progress
+  const agents = [${[taskAnalysis.primaryAgent, ...taskAnalysis.supportingAgents].map(a => `"${a}"`).join(', ')}];
+  for (const agent of agents) {
+    const progress = agentStates.find(s => s.includes(\`agent_\${agent}_progress\`));
+    cliLogger.info(\`Agent \${agent}: \${progress ? 'active' : 'waiting'}\`);
+  }
+}, 10000); // Every 10 seconds
+
+// Also update main session state
+await mcp__snow-flow__memory_usage({
+  key: "swarm_session_${sessionId}",
+  value: JSON.stringify({
+    status: "agents_working",
+    last_check: new Date().toISOString()
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+
+### 6. Coordinate Agent Handoffs
+Ensure smooth transitions between agents:
+
+\`\`\`javascript
+// Primary agent signals readiness for support
+Memory.store("agent_${taskAnalysis.primaryAgent}_ready_for_support", {
+  base_structure_complete: true,
+  ready_for: [${taskAnalysis.supportingAgents.map(a => `"${a}"`).join(', ')}],
+  timestamp: new Date().toISOString()
+});
+
+// Supporting agents check readiness
+const canProceed = Memory.get("agent_${taskAnalysis.primaryAgent}_ready_for_support");
+if (canProceed?.base_structure_complete) {
+  // Begin supporting work
+}
+\`\`\`
+
+### 7. Final Validation and Completion
+Once all agents complete their work:
+
+\`\`\`javascript
+// Collect all agent outputs
+const agentOutputs = {};
+[${[taskAnalysis.primaryAgent, ...taskAnalysis.supportingAgents].map(a => `"${a}"`).join(', ')}].forEach(agent => {
+  const output = Memory.get(\`agent_\${agent}_complete\`);
+  if (output) {
+    agentOutputs[agent] = output;
+  }
+});
+
+// Store final swarm results
+Memory.store("swarm_session_${sessionId}_results", {
+  objective: "${objective}",
+  completed_at: new Date().toISOString(),
+  agent_outputs: agentOutputs,
+  artifacts_created: Object.values(agentOutputs)
+    .flatMap(output => output.artifacts_created || []),
+  success: true
+});
+
+// Update final TodoWrite status
+TodoWrite([
+  {
+    id: "swarm_completion",
+    content: "Swarm successfully completed: ${objective}",
+    status: "completed",
+    priority: "high"
+  }
+]);
+\`\`\`
+
+## 📊 Progress Monitoring Pattern
+
+${options.progressMonitoring ? `### Real-Time Progress Monitoring Enabled
+Monitor swarm progress using these patterns:
+
+\`\`\`javascript
+// Regular progress checks
+setInterval(() => {
+  const session = Memory.get("swarm_session_${sessionId}");
+  const todos = TodoRead();
+  
+  cliLogger.info(\`Swarm Status: \${session.status}\`);
+  cliLogger.info(\`Tasks Completed: \${todos.filter(t => t.status === 'completed').length}/\${todos.length}\`);
+  
+  // Check individual agent progress
+  checkAgentProgress();
+}, 30000); // Check every 30 seconds
+\`\`\`
+` : '### Manual Progress Checking\nUse TodoRead and Memory tools to check progress periodically.'}
+
+## 🎯 Success Criteria
+
+Your Queen Agent orchestration is successful when:
+1. ✅ All agents have been spawned and initialized
+2. ✅ Swarm session is tracked in Memory
+3. ✅ Agents are coordinating through shared Memory
+4. ✅ TodoWrite is being used for task tracking
+5. ✅ Progress is being monitored
+6. ✅ ${taskAnalysis.taskType} requirements are met
+7. ✅ All artifacts are created/deployed successfully
+
+## 💡 Queen Agent Best Practices
+
+1. **Spawn agents concurrently** when tasks are independent
+2. **Use Memory prefixes** to avoid key collisions
+3. **Update TodoWrite** frequently for visibility
+4. **Monitor agent health** and restart if needed
+5. **Validate outputs** before marking complete
+6. **Store all decisions** in Memory for audit trail
+
+## 📋 Agent-Specific Authentication & Discovery Workflows
+
+### 🛠️ Widget Creator Agent
+\`\`\`javascript
+// Pre-flight check
+const authCheck = await snow_find_artifact({ query: "test auth", type: "widget" });
+if (authCheck.error?.includes("OAuth")) {
+  // Switch to planning mode
+  Memory.store("widget_plan", {
+    html_template: "<!-- Complete HTML structure -->",
+    server_script: "// Complete server logic",
+    client_script: "// Complete client controller",
+    css_styles: "/* Complete styles */",
+    deployment_instructions: "Run snow-flow auth login, then use snow_deploy"
+  });
+  TodoWrite([{ content: "Widget plan ready - auth required for deployment", status: "completed" }]);
+} else {
+  // Continue with live development
+  const existing = await snow_comprehensive_search({ query: "similar widget" });
+  // ... proceed with snow_deploy
+}
+\`\`\`
+
+### 🔄 Flow Builder Agent
+\`\`\`javascript
+// Check existing flows first
+const flows = await snow_discover_existing_flows({ flow_purpose: "objective" });
+if (flows.error?.includes("OAuth")) {
+  // Document flow architecture
+  Memory.store("flow_plan", {
+    trigger: "When record created on [table]",
+    steps: ["Step 1: Validate data", "Step 2: Process", "Step 3: Notify"],
+    natural_language: "Complete flow instruction for snow_create_flow",
+    deployment_command: "snow_create_flow with deploy_immediately: true"
+  });
+} else {
+  // Create flow directly using XML-first approach
+  await snow_create_flow({ 
+    instruction: "natural language description",
+    deploy_immediately: true 
+  });
+}
+\`\`\`
+
+### 📝 Script Writer Agent
+\`\`\`javascript
+// Verify permissions
+const permCheck = await snow_get_by_sysid({ 
+  sys_id: "test", // Example sys_id - replace with actual value
+  table: "sys_script_include" 
+});
+if (permCheck.error?.includes("OAuth")) {
+  // Complete script documentation
+  Memory.store("script_solution", {
+    script_type: "Business Rule/Script Include/etc",
+    code: "// Complete implementation",
+    when: "before/after/async",
+    table: "target_table",
+    deployment_ready: true
+  });
+}
+\`\`\`
+
+### 🧪 Tester Agent
+\`\`\`javascript
+// Tester can start with mock (always works)
+const mockTest = await snow_test_flow_with_mock({
+  flow_id: "flow_name",
+  test_inputs: { /* test data */ }
+});
+// Then try comprehensive if authenticated
+// 🔧 TEST-001 FIX: Skip live test if no valid flow sys_id is available
+// Only run live test if we have a real sys_id from previous flow creation
+let liveTest: any = { error: "No valid flow_sys_id available for live testing" };
+
+// In practice, this would get the sys_id from a previously created flow:
+// if (Memory.get("last_created_flow_sys_id")) {
+//   liveTest = await snow_comprehensive_flow_test({ 
+//     flow_sys_id: Memory.get("last_created_flow_sys_id") 
+//   });
+// }
+
+if (liveTest.error) {
+  // Document test results from mock only
+  Memory.store("test_results", mockTest);
+}
+\`\`\`
+
+## 🚀 Begin Orchestration
+
+Now execute this Queen Agent orchestration plan:
+1. Initialize the swarm session in Memory
+2. Create the master task list with TodoWrite
+3. Spawn all required agents using Task
+4. Monitor progress and coordinate
+5. Validate and complete the objective
+
+Remember: You are the Queen Agent - the master coordinator. Your role is to ensure all agents work harmoniously to achieve the objective: "${objective}"
+
+${hasAutonomousSystems ? `
+
+## 🤖 AUTONOMOUS SYSTEMS INTEGRATION
+
+**CRITICAL: The following autonomous systems have been enabled and MUST be initialized:**
+
+${autonomousDocActive ? `
+### 📚 Self-Documenting System
+**MANDATORY**: Initialize and start autonomous documentation:
+\`\`\`javascript
+// Start continuous documentation monitoring
+await snow_start_continuous_documentation({
+  auto_commit: true,
+  include_diagrams: true,
+  scope: "full"
+});
+
+// Store status in memory
+await mcp__snow-flow__memory_usage({
+  key: "autonomous_documentation_${sessionId}",
+  value: JSON.stringify({ 
+    status: "active", 
+    started_at: new Date().toISOString(),
+    auto_commit: true 
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+` : ''}
+
+${autonomousCostActive ? `
+### 💰 Cost Optimization Engine
+**MANDATORY**: Initialize and start autonomous cost optimization:
+\`\`\`javascript
+// Start autonomous cost optimization
+await snow_start_autonomous_cost_optimization({
+  target_savings: 30,
+  auto_implement: true,
+  monitor_real_time: true
+});
+
+// Store status in memory
+await mcp__snow-flow__memory_usage({
+  key: "autonomous_cost_optimization_${sessionId}",
+  value: JSON.stringify({ 
+    status: "active", 
+    started_at: new Date().toISOString(),
+    target_savings: 30,
+    auto_implement: true 
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+` : ''}
+
+${autonomousComplianceActive ? `
+### 🔐 Advanced Compliance System
+**MANDATORY**: Initialize and start autonomous compliance monitoring:
+\`\`\`javascript
+// Start compliance monitoring
+await snow_start_compliance_monitoring({
+  frameworks: ["GDPR", "SOX", "HIPAA"],
+  auto_remediate: true,
+  continuous_monitoring: true
+});
+
+// Store status in memory
+await mcp__snow-flow__memory_usage({
+  key: "autonomous_compliance_${sessionId}",
+  value: JSON.stringify({ 
+    status: "active", 
+    started_at: new Date().toISOString(),
+    frameworks: ["GDPR", "SOX", "HIPAA"],
+    auto_remediate: true 
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+` : ''}
+
+${autonomousHealingActive ? `
+### 🏥 Self-Healing System
+**MANDATORY**: Initialize and start autonomous self-healing:
+\`\`\`javascript
+// Start self-healing system
+await snow_start_autonomous_healing({
+  preventive: true,
+  auto_heal: true,
+  learn_patterns: true
+});
+
+// Store status in memory
+await mcp__snow-flow__memory_usage({
+  key: "autonomous_healing_${sessionId}",
+  value: JSON.stringify({ 
+    status: "active", 
+    started_at: new Date().toISOString(),
+    preventive: true,
+    auto_heal: true 
+  }),
+  namespace: "swarm_${sessionId}"
+});
+\`\`\`
+` : ''}
+
+**🎯 ORCHESTRATOR SHOWCASE:** These autonomous systems operate without manual intervention, demonstrating true orchestration capabilities. They will:
+- Monitor continuously in the background
+- Make intelligent decisions automatically
+- Adapt and learn from patterns
+- Provide real-time dashboards and insights
+- Execute actions autonomously when needed
+
+**Integration with Main Objective:** All autonomous systems will coordinate with your main objective ("${objective}") by providing:
+- Automatic documentation of created artifacts
+- Cost optimization of operations performed
+- Compliance validation of all changes
+- Self-healing of any issues that arise
+
+` : ''}
+
+Session ID for this swarm: ${sessionId}`;
+
+  return prompt;
+}
+
+function getTeamRecommendation(taskType: string): string {
+  switch (taskType) {
+    case 'widget_development':
+      return 'Widget Development Team (Frontend + Backend + UI/UX + Platform + QA)';
+    case 'flow_development':
+      return 'Flow Development Team (Process + Trigger + Data + Integration + Security)';
+    case 'application_development':
+      return 'Application Development Team (Database + Business Logic + Interface + Security + Performance)';
+    case 'integration':
+      return 'Individual Integration Specialist or Adaptive Team';
+    case 'security_review':
+      return 'Individual Security Specialist';
+    case 'performance_optimization':
+      return 'Individual Backend Specialist or Adaptive Team';
+    default:
+      return 'Adaptive Team (dynamically assembled based on requirements)';
+  }
+}
+
+function getServiceNowInstructions(taskType: string): string {
+  const taskTitle = taskType.split('_').map(word => 
+    word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(' ');
+  
+  return `**${taskTitle} Process:**
+The team-based SPARC architecture will handle the complete development process.
+Refer to CLAUDE.md for detailed instructions and best practices specific to ${taskType}.`;
+}
+
+function getExpectedDeliverables(taskType: string, isAuthenticated: boolean = false): string {
+  const taskTitle = taskType.split('_').map(word => 
+    word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(' ');
+  
+  if (isAuthenticated) {
+    return `The team will deliver a complete ${taskTitle.toLowerCase()} solution directly to ServiceNow.
+All artifacts will be created in your ServiceNow instance with proper Update Set tracking.
+Refer to CLAUDE.md for specific deliverables based on your task type.`;
+  } else {
+    return `The team will create ${taskTitle.toLowerCase()} artifacts as local files.
+Files will be organized in the servicenow/ directory for easy import.
+Refer to CLAUDE.md for specific deliverables based on your task type.`;
+  }
+}
+
+// Helper function to analyze objectives using intelligent agent detection
+function analyzeObjective(objective: string, userMaxAgents?: number): TaskAnalysis {
+  return AgentDetector.analyzeTask(objective, userMaxAgents);
+}
+
+function extractName(objective: string, type: string): string {
+  const words = objective.split(' ');
+  const typeIndex = words.findIndex(w => w.toLowerCase().includes(type));
+  if (typeIndex >= 0 && typeIndex < words.length - 1) {
+    return words.slice(typeIndex + 1).join(' ').replace(/['"]/g, '');
+  }
+  return `Generated ${type}`;
+}
+
+/**
+ * Generate intelligent agent spawning strategy based on task dependencies
+ * Creates execution batches for sequential and parallel execution
+ */
+function getAgentSpawnStrategy(taskAnalysis: any): string {
+  const { primaryAgent, supportingAgents, taskType, serviceNowArtifacts } = taskAnalysis;
+  
+  // Define agent dependencies - which agents must run before others
+  const agentDependencies: { [key: string]: string[] } = {
+    // Architecture/Design agents must run first
+    'architect': [],
+    'app-architect': [],
+    
+    // Script/Code agents depend on architecture
+    'script-writer': ['architect', 'app-architect'],
+    'coder': ['architect', 'app-architect'],
+    
+    // UI agents can run after architecture, parallel with backend
+    'widget-creator': ['architect', 'app-architect'],
+    'css-specialist': ['widget-creator'],
+    'frontend-specialist': ['widget-creator'],
+    'backend-specialist': ['architect', 'app-architect'],
+    
+    // Flow agents depend on architecture
+    'flow-builder': ['architect', 'app-architect'],
+    'trigger-specialist': ['flow-builder'],
+    'action-specialist': ['flow-builder'],
+    'approval-specialist': ['flow-builder'],
+    
+    // Integration agents can run in parallel with others
+    'integration-specialist': ['architect'],
+    'api-specialist': ['architect'],
+    
+    // Testing/Security agents run last
+    'tester': ['script-writer', 'widget-creator', 'flow-builder', 'frontend-specialist', 'backend-specialist'],
+    'security-specialist': ['script-writer', 'api-specialist'],
+    'performance-specialist': ['frontend-specialist', 'backend-specialist'],
+    
+    // Error handling depends on main implementation
+    'error-handler': ['flow-builder', 'script-writer'],
+    
+    // Documentation can run in parallel
+    'documentation-specialist': [],
+    
+    // Specialized agents
+    'ml-developer': ['architect', 'script-writer'],
+    'database-expert': ['architect'],
+    'analyst': ['architect']
+  };
+  
+  // Create dependency graph
+  const allAgents = [primaryAgent, ...supportingAgents];
+  const agentBatches: string[][] = [];
+  const processedAgents = new Set<string>();
+  
+  // Helper to check if all dependencies are met
+  const canExecute = (agent: string): boolean => {
+    const deps = agentDependencies[agent] || [];
+    return deps.every(dep => processedAgents.has(dep));
+  };
+  
+  // Create batches based on dependencies
+  while (processedAgents.size < allAgents.length) {
+    const currentBatch: string[] = [];
+    
+    for (const agent of allAgents) {
+      if (!processedAgents.has(agent) && canExecute(agent)) {
+        currentBatch.push(agent);
+      }
+    }
+    
+    if (currentBatch.length === 0) {
+      // Circular dependency or missing dependency - add remaining agents
+      for (const agent of allAgents) {
+        if (!processedAgents.has(agent)) {
+          currentBatch.push(agent);
+        }
+      }
+    }
+    
+    if (currentBatch.length > 0) {
+      agentBatches.push(currentBatch);
+      currentBatch.forEach(agent => processedAgents.add(agent));
+    }
+  }
+  
+  // Generate the strategy prompt
+  let strategy = `
+**🧠 Intelligent Dependency-Based Agent Execution Plan:**
+
+`;
+  
+  // Show execution batches
+  agentBatches.forEach((batch, index) => {
+    const isParallel = batch.length > 1;
+    const executionType = isParallel ? '⚡ PARALLEL EXECUTION' : '📦 SEQUENTIAL STEP';
+    
+    strategy += `**Batch ${index + 1} - ${executionType}:**\n`;
+    
+    if (isParallel) {
+      strategy += `\`\`\`javascript
+// 🚀 Execute these ${batch.length} agents IN PARALLEL (single message, multiple Tasks)
+`;
+      batch.forEach(agent => {
+        const agentPrompt = getAgentPromptForBatch(agent, taskType);
+        strategy += `Task("${agent}", \`${agentPrompt}\`);
+`;
+      });
+      strategy += `\`\`\`\n\n`;
+    } else {
+      strategy += `\`\`\`javascript
+// 📦 Execute this agent FIRST before proceeding
+`;
+      const agent = batch[0];
+      const agentPrompt = getAgentPromptForBatch(agent, taskType);
+      strategy += `Task("${agent}", \`${agentPrompt}\`);
+`;
+      strategy += `\`\`\`\n\n`;
+    }
+    
+    // Add wait/coordination note if not the last batch
+    if (index < agentBatches.length - 1) {
+      strategy += `**⏸️ WAIT for Batch ${index + 1} completion before proceeding to Batch ${index + 2}**\n\n`;
+    }
+  });
+  
+  // Add execution summary
+  const totalBatches = agentBatches.length;
+  const parallelBatches = agentBatches.filter(b => b.length > 1).length;
+  const maxParallelAgents = Math.max(...agentBatches.map(b => b.length));
+  
+  strategy += `
+**📊 Execution Summary:**
+- Total Execution Batches: ${totalBatches}
+- Parallel Batches: ${parallelBatches}
+- Sequential Steps: ${totalBatches - parallelBatches}
+- Max Parallel Agents: ${maxParallelAgents}
+- Estimated Time Reduction: ${Math.round((1 - (totalBatches / allAgents.length)) * 100)}%
+
+**🔄 Dependency Flow:**
+`;
+  
+  // Show visual dependency flow
+  agentBatches.forEach((batch, index) => {
+    if (index === 0) {
+      strategy += `START → `;
+    }
+    
+    if (batch.length === 1) {
+      strategy += `[${batch[0]}]`;
+    } else {
+      strategy += `[${batch.join(' | ')}]`;
+    }
+    
+    if (index < agentBatches.length - 1) {
+      strategy += ` → `;
+    } else {
+      strategy += ` → COMPLETE`;
+    }
+  });
+  
+  strategy += `\n`;
+  
+  return strategy;
+}
+
+/**
+ * Generate agent-specific prompts for batch execution
+ */
+function getAgentPromptForBatch(agentType: string, taskType: string): string {
+  const basePrompts: { [key: string]: string } = {
+    'architect': 'You are the architect agent. Design the system architecture and data models. Store your design in Memory for other agents.',
+    'app-architect': 'You are the application architect. Design the overall application structure and component interfaces.',
+    'script-writer': 'You are the script writer. Implement business logic and scripts based on the architecture. Check Memory for design specs.',
+    'widget-creator': 'You are the widget creator. Build the HTML structure for Service Portal widgets. Store widget specs in Memory.',
+    'css-specialist': 'You are the CSS specialist. Create responsive styles for the widgets. Read widget structure from Memory.',
+    'frontend-specialist': 'You are the frontend specialist. Implement client-side JavaScript. Coordinate with backend via Memory.',
+    'backend-specialist': 'You are the backend specialist. Implement server-side logic. Coordinate with frontend via Memory.',
+    'flow-builder': 'You are the flow builder. Create the main flow structure. Store flow design in Memory for specialists.',
+    'trigger-specialist': 'You are the trigger specialist. Configure flow triggers based on the flow design in Memory.',
+    'action-specialist': 'You are the action specialist. Implement flow actions based on the flow design in Memory.',
+    'approval-specialist': 'You are the approval specialist. Set up approval processes in the flow.',
+    'integration-specialist': 'You are the integration specialist. Handle external system integrations and APIs.',
+    'api-specialist': 'You are the API specialist. Design and implement REST/SOAP endpoints.',
+    'tester': 'You are the tester. Test all components created by other agents. Read their outputs from Memory.',
+    'security-specialist': 'You are the security specialist. Implement security best practices and access controls.',
+    'performance-specialist': 'You are the performance specialist. Optimize code and queries for performance.',
+    'error-handler': 'You are the error handler. Implement comprehensive error handling and logging.',
+    'documentation-specialist': 'You are the documentation specialist. Create comprehensive documentation.',
+    'ml-developer': 'You are the ML developer. Implement machine learning features using ServiceNow ML tools.',
+    'database-expert': 'You are the database expert. Design and optimize database schemas and queries.',
+    'analyst': 'You are the analyst. Analyze requirements and provide insights for implementation.'
+  };
+  
+  const prompt = basePrompts[agentType] || `You are the ${agentType} agent. Perform your specialized tasks.`;
+  
+  return `${prompt}
+MANDATORY: 
+1. Run npx snow-flow hooks pre-task --description "${taskType} - ${agentType}"
+2. Store ALL decisions in Memory with key "agent_${agentType}_decisions"
+3. Check Memory for work from agents you depend on
+4. After EVERY file operation, run npx snow-flow hooks post-edit
+5. When complete, run npx snow-flow hooks post-task --task-id "${agentType}"`;
+}
+
+// Swarm status command - monitor running swarms
+program
+  .command('swarm-status [sessionId]')
+  .description('Check the status of a running swarm session')
+  .option('--watch', 'Continuously monitor the swarm progress')
+  .option('--interval <seconds>', 'Watch interval in seconds', '5')
+  .action(async (sessionId: string | undefined, options) => {
+    cliLogger.info('\n🔍 Checking swarm status...\n');
+    
+    try {
+      const { QueenMemorySystem } = await import('./queen/queen-memory.js');
+      const memorySystem = new QueenMemorySystem();
+      
+      if (!sessionId) {
+        // List all recent swarm sessions
+        cliLogger.info('📋 Recent swarm sessions:');
+        cliLogger.info('(Provide a session ID to see detailed status)\n');
+        
+        // Get all session keys from learnings
+        const sessionKeys: string[] = [];
+        // Note: This is a simplified approach - in production, you'd query the memory files directly
+        cliLogger.info('💡 Use: snow-flow swarm-status <sessionId> to see details');
+        cliLogger.info('💡 Session IDs are displayed when you start a swarm\n');
+        return;
+      }
+      
+      // Get specific session data
+      const sessionData = memorySystem.getLearning(`session_${sessionId}`);
+      const launchData = memorySystem.getLearning(`launch_${sessionId}`);
+      const errorData = memorySystem.getLearning(`error_${sessionId}`);
+      
+      if (!sessionData) {
+        console.error(`❌ No swarm session found with ID: ${sessionId}`);
+        cliLogger.info('💡 Make sure to use the exact session ID displayed when starting the swarm');
+        return;
+      }
+      
+      cliLogger.info(`👑 Swarm Session: ${sessionId}`);
+      cliLogger.info(`📋 Objective: ${sessionData.objective}`);
+      cliLogger.info(`🕐 Started: ${sessionData.started_at}`);
+      cliLogger.info(`📊 Task Type: ${sessionData.taskAnalysis.taskType}`);
+      cliLogger.info(`🤖 Agents: ${sessionData.taskAnalysis.estimatedAgentCount} total`);
+      cliLogger.info(`   - Primary: ${sessionData.taskAnalysis.primaryAgent}`);
+      cliLogger.info(`   - Supporting: ${sessionData.taskAnalysis.supportingAgents.join(', ')}`);
+      
+      if (launchData && launchData.success) {
+        cliLogger.info(`\n✅ Status: Claude Code launched successfully`);
+        cliLogger.info(`🚀 Launched at: ${launchData.launched_at}`);
+      } else if (errorData) {
+        cliLogger.error(`\n❌ Status: Error occurred`);
+        cliLogger.error(`💥 Error: ${errorData.error}`);
+        cliLogger.error(`🕐 Failed at: ${errorData.failed_at}`);
+      } else {
+        cliLogger.info(`\n⏳ Status: Awaiting manual Claude Code execution`);
+      }
+      
+      cliLogger.info('\n💡 Tips:');
+      cliLogger.info('   - Check Claude Code for real-time agent progress');
+      cliLogger.info('   - Use Memory.get("swarm_session_' + sessionId + '") in Claude Code');
+      cliLogger.info('   - Monitor TodoRead for task completion status');
+      
+      if (options.watch) {
+        cliLogger.info(`\n👀 Watching for updates every ${options.interval} seconds...`);
+        cliLogger.info('(Press Ctrl+C to stop)\n');
+        
+        const watchInterval = setInterval(async () => {
+          // In a real implementation, this would query Claude Code's memory
+          cliLogger.info(`[${new Date().toLocaleTimeString()}] Checking for updates...`);
+          
+          // Re-fetch session data to check for updates
+          const updatedSession = memorySystem.getLearning(`session_${sessionId}`);
+          if (updatedSession) {
+            cliLogger.info('   Status: Active - Check Claude Code for details');
+          }
+        }, parseInt(options.interval) * 1000);
+        
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+          clearInterval(watchInterval);
+          cliLogger.info('\n\n✋ Stopped watching swarm status');
+          process.exit(0);
+        });
+      }
+      
+    } catch (error) {
+      console.error('❌ Failed to check swarm status:', error instanceof Error ? error.message : String(error));
+    }
+  });
+
+// Spawn agent command
+program
+  .command('spawn <type>')
+  .description('Spawn a specific agent type')
+  .option('--name <name>', 'Custom agent name')
+  .action(async (type: string, options) => {
+    cliLogger.info(`🤖 Spawning ${type} agent${options.name ? ` with name "${options.name}"` : ''}...`);
+    cliLogger.info(`✅ Agent spawned successfully`);
+    cliLogger.info(`📋 Agent capabilities:`);
+    
+    if (type === 'widget-builder') {
+      cliLogger.info('   ├── Service Portal widget creation');
+      cliLogger.info('   ├── HTML/CSS template generation');
+      cliLogger.info('   ├── Client script development');
+      cliLogger.info('   └── Server script implementation');
+    } else if (type === 'workflow-designer') {
+      cliLogger.info('   ├── Flow Designer workflow creation');
+      cliLogger.info('   ├── Process automation');
+      cliLogger.info('   ├── Approval routing');
+      cliLogger.info('   └── Integration orchestration');
+    } else {
+      cliLogger.info('   ├── Generic ServiceNow development');
+      cliLogger.info('   ├── Script generation');
+      cliLogger.info('   ├── Configuration management');
+      cliLogger.info('   └── API integration');
+    }
+  });
+
+// Status command
+program
+  .command('status')
+  .description('Show orchestrator status')
+  .action(async () => {
+    cliLogger.info('\n🔍 ServiceNow Multi-Agent Orchestrator Status');
+    cliLogger.info('=============================================');
+    cliLogger.info('📊 System Status: ✅ Online');
+    cliLogger.info('🤖 Available Agents: 5');
+    cliLogger.info('📋 Queue Status: Empty');
+    cliLogger.info('🔗 ServiceNow Connection: Not configured');
+    cliLogger.info('💾 Memory Usage: 45MB');
+    cliLogger.info('🕒 Uptime: 00:05:23');
+    
+    cliLogger.info('\n🤖 Agent Types:');
+    cliLogger.info('   ├── widget-builder: Available');
+    cliLogger.info('   ├── workflow-designer: Available');
+    cliLogger.info('   ├── script-generator: Available');
+    cliLogger.info('   ├── ui-builder: Available');
+    cliLogger.info('   └── app-creator: Available');
+    
+    cliLogger.info('\n⚙️  Configuration:');
+    cliLogger.info('   ├── Instance: Not set');
+    cliLogger.info('   ├── Authentication: Not configured');
+    cliLogger.info('   └── Mode: Development');
+  });
+
+// Monitor command - real-time dashboard
+program
+  .command('monitor')
+  .description('Show real-time monitoring dashboard')
+  .option('--duration <seconds>', 'Duration to monitor (default: 60)', '60')
+  .action(async (options) => {
+    const duration = parseInt(options.duration) * 1000;
+    cliLogger.info('🚀 Starting Snow-Flow Real-Time Monitor...\n');
+    
+    let iterations = 0;
+    const startTime = Date.now();
+    
+    const monitoringInterval = setInterval(() => {
+      iterations++;
+      const uptime = Math.floor((Date.now() - startTime) / 1000);
+      const minutes = Math.floor(uptime / 60);
+      const seconds = uptime % 60;
+      
+      // Clear previous lines and show dashboard
+      if (iterations > 1) {
+        process.stdout.write('\x1B[12A'); // Move cursor up 12 lines
+        process.stdout.write('\x1B[2K'); // Clear line
+      }
+      
+      cliLogger.info('┌─────────────────────────────────────────────────────────────┐');
+      console.log(`│               🚀 Snow-Flow Monitor v${VERSION}                   │`);
+      console.log('├─────────────────────────────────────────────────────────────┤');
+      console.log(`│ 📊 System Status:       ✅ Online                          │`);
+      console.log(`│ ⏱️  Monitor Time:        ${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}                          │`);
+      console.log(`│ 🔄 Update Cycles:       ${iterations}                                │`);
+      console.log(`│ 🤖 Available Agents:    5                                   │`);
+      console.log(`│ 💾 Memory Usage:        ~45MB                               │`);
+      console.log('├─────────────────────────────────────────────────────────────┤');
+      console.log('│ 📋 Recent Activity:                                        │');
+      console.log(`│   • ${new Date().toLocaleTimeString()} - System monitoring active     │`);
+      cliLogger.info('└─────────────────────────────────────────────────────────────┘');
+      
+      // Check for active Claude Code processes
+      try {
+        const { execSync } = require('child_process');
+        const processes = execSync('ps aux | grep "claude" | grep -v grep', { encoding: 'utf8' }).toString();
+        if (processes.trim()) {
+          cliLogger.info('\n🤖 Active Claude Code Processes:');
+          const lines = processes.trim().split('\n');
+          lines.forEach((line: string, index: number) => {
+            if (index < 3) { // Show max 3 processes
+              const parts = line.split(/\s+/);
+              const pid = parts[1];
+              const cpu = parts[2];
+              const mem = parts[3];
+              cliLogger.info(`   Process ${pid}: CPU ${cpu}%, Memory ${mem}%`);
+            }
+          });
+        }
+      } catch (error) {
+        // No active processes or error occurred
+      }
+      
+      // Check generated files
+      try {
+        const serviceNowDir = join(process.cwd(), 'servicenow');
+        fs.readdir(serviceNowDir).then(files => {
+          if (files.length > 0) {
+            cliLogger.info(`\n📁 Generated Artifacts: ${files.length} files in servicenow/`);
+            files.slice(0, 3).forEach(file => {
+              cliLogger.info(`   • ${file}`);
+            });
+            if (files.length > 3) {
+              cliLogger.info(`   ... and ${files.length - 3} more files`);
+            }
+          }
+        }).catch(() => {
+          // Directory doesn't exist yet
+        });
+      } catch (error) {
+        // Ignore errors
+      }
+      
+    }, 2000); // Update every 2 seconds
+    
+    // Stop monitoring after duration
+    setTimeout(() => {
+      clearInterval(monitoringInterval);
+      cliLogger.info('\n✅ Monitoring completed. Use --duration <seconds> to monitor longer.');
+    }, duration);
+  });
+
+// Memory commands
+program
+  .command('memory <action> [key] [value]')
+  .description('Memory operations (store, get, list)')
+  .action(async (action: string, key?: string, value?: string) => {
+    cliLogger.info(`💾 Memory ${action}${key ? `: ${key}` : ''}`);
+    
+    if (action === 'store' && key && value) {
+      cliLogger.info(`✅ Stored: ${key} = ${value}`);
+    } else if (action === 'get' && key) {
+      cliLogger.info(`📖 Retrieved: ${key} = [simulated value]`);
+    } else if (action === 'list') {
+      cliLogger.info('📚 Memory contents:');
+      cliLogger.info('   ├── last_widget: incident_management_widget');
+      cliLogger.info('   ├── last_workflow: approval_process');
+      cliLogger.info('   └── session_id: snow-flow-session-123');
+    } else {
+      cliLogger.error('❌ Invalid memory operation');
+    }
+  });
+
+// Auth command - OAuth implementation
+program
+  .command('auth <action>')
+  .description('Authentication management (login, logout, status)')
+  .option('--instance <instance>', 'ServiceNow instance (e.g., dev12345.service-now.com)')
+  .option('--client-id <clientId>', 'OAuth Client ID')
+  .option('--client-secret <clientSecret>', 'OAuth Client Secret')
+  .action(async (action: string, options) => {
+    const oauth = new ServiceNowOAuth();
+    
+    if (action === 'login') {
+      cliLogger.info('🔑 Starting ServiceNow OAuth authentication...');
+      
+      // Get credentials from options or environment
+      const instance = options.instance || process.env.SNOW_INSTANCE;
+      const clientId = options.clientId || process.env.SNOW_CLIENT_ID;
+      const clientSecret = options.clientSecret || process.env.SNOW_CLIENT_SECRET;
+      
+      if (!instance || !clientId || !clientSecret) {
+        console.error('❌ Missing required OAuth credentials');
+        cliLogger.info('\n📝 Please provide:');
+        cliLogger.info('   --instance: ServiceNow instance (e.g., dev12345.service-now.com)');
+        cliLogger.info('   --client-id: OAuth Client ID');
+        cliLogger.info('   --client-secret: OAuth Client Secret');
+        cliLogger.info('\n💡 Or set environment variables:');
+        cliLogger.info('   export SNOW_INSTANCE=your-instance.service-now.com');
+        cliLogger.info('   export SNOW_CLIENT_ID=your-client-id');
+        cliLogger.info('   export SNOW_CLIENT_SECRET=your-client-secret');
+        return;
+      }
+      
+      // Start OAuth flow
+      const result = await oauth.authenticate(instance, clientId, clientSecret);
+      
+      if (result.success) {
+        cliLogger.info('\n✅ Authentication successful!');
+        cliLogger.info('🎉 Snow-Flow is now connected to ServiceNow!');
+        cliLogger.info('\n📋 Next steps:');
+        cliLogger.info('   1. Test connection: snow-flow auth status');
+        cliLogger.info('   2. Start development: snow-flow swarm "create a widget for incident management"');
+        
+        // Test connection
+        const client = new ServiceNowClient();
+        const testResult = await client.testConnection();
+        if (testResult.success) {
+          cliLogger.info(`\n🔍 Connection test successful!`);
+          cliLogger.info(`👤 Logged in as: ${testResult.data.name} (${testResult.data.user_name})`);
+        }
+      } else {
+        console.error(`\n❌ Authentication failed: ${result.error}`);
+        process.exit(1);
+      }
+      
+    } else if (action === 'logout') {
+      cliLogger.info('🔓 Logging out...');
+      await oauth.logout();
+      
+    } else if (action === 'status') {
+      cliLogger.info('📊 Authentication Status:');
+      
+      const isAuthenticated = await oauth.isAuthenticated();
+      const credentials = await oauth.loadCredentials();
+      
+      if (isAuthenticated && credentials) {
+        console.log('   ├── Status: ✅ Authenticated');
+        console.log(`   ├── Instance: ${credentials.instance}`);
+        console.log('   ├── Method: OAuth 2.0');
+        console.log(`   ├── Client ID: ${credentials.clientId}`);
+        
+        if (credentials.expiresAt) {
+          const expiresAt = new Date(credentials.expiresAt);
+          console.log(`   └── Token expires: ${expiresAt.toLocaleString()}`);
+        }
+        
+        // Test connection
+        const client = new ServiceNowClient();
+        const testResult = await client.testConnection();
+        if (testResult.success) {
+          console.log(`\n🔍 Connection test: ✅ Success`);
+          if (testResult.data.message) {
+            console.log(`   ${testResult.data.message}`);
+          }
+          console.log(`🌐 Instance: ${testResult.data.email || credentials.instance}`);
+        } else {
+          console.log(`\n🔍 Connection test: ❌ Failed`);
+          console.log(`   Error: ${testResult.error}`);
+        }
+      } else {
+        console.log('   ├── Status: ❌ Not authenticated');
+        console.log('   ├── Instance: Not configured');
+        console.log('   └── Method: Not set');
+        console.log('\n💡 Run "snow-flow auth login" to authenticate');
+      }
+    } else {
+      console.log('❌ Invalid action. Use: login, logout, or status');
+    }
+  });
+
+
+// Initialize Snow-Flow project
+program
+  .command('init')
+  .description('Initialize a Snow-Flow project with full AI-powered environment')
+  .option('--sparc', '[Deprecated] SPARC is now included by default', true)
+  .option('--skip-mcp', 'Skip MCP server activation prompt')
+  .option('--force', 'Overwrite existing files without prompting')
+  .action(async (options) => {
+    console.log(chalk.blue.bold(`\n🚀 Initializing Snow-Flow Project v${VERSION}...`));
+    console.log('='.repeat(60));
+    
+    const targetDir = process.cwd();
+    
+    try {
+      // Check for .snow-flow migration
+      const { migrationUtil } = await import('./utils/migrate-snow-flow.js');
+      if (await migrationUtil.checkMigrationNeeded()) {
+        console.log('\n🔄 Detected .snow-flow directory, migrating to .snow-flow...');
+        await migrationUtil.migrate();
+      }
+      
+      // Create directory structure
+      console.log('\n📁 Creating project structure...');
+      await createDirectoryStructure(targetDir, options.force);
+      
+      // Create .env file
+      console.log('🔐 Creating environment configuration...');
+      await createEnvFile(targetDir, options.force);
+      
+      // Create MCP configuration - always included now (SPARC is default)
+      console.log('🔧 Setting up MCP servers for Claude Code...');
+      await createMCPConfig(targetDir, options.force);
+      
+      // Copy CLAUDE.md file
+      console.log('📚 Creating documentation files...');
+      await copyCLAUDEmd(targetDir, options.force);
+      
+      // Create README files
+      await createReadmeFiles(targetDir, options.force);
+      
+      console.log(chalk.green.bold('\n✅ Snow-Flow project initialized successfully!'));
+      console.log('\n📋 Created files and directories:');
+      console.log('   ✓ .claude/ - Claude Code configuration');
+      console.log('   ✓ .swarm/ - Swarm session management');
+      console.log('   ✓ .snow-flow/ - Snow-Flow project data (Queen, memory, tests)');
+      console.log('   ✓ memory/ - Persistent memory storage');
+      console.log('   ✓ .env - ServiceNow OAuth configuration');
+      console.log('   ✓ .mcp.json - MCP server configuration');
+      console.log('   ✓ CLAUDE.md - Development documentation');
+      console.log('   ✓ README.md - Project documentation');
+      
+      if (!options.skipMcp) {
+        // Start MCP servers automatically
+        console.log(chalk.yellow.bold('\n🚀 Starting MCP servers in the background...'));
+        
+        try {
+          const { MCPServerManager } = await import('./utils/mcp-server-manager.js');
+          const manager = new MCPServerManager();
+          await manager.initialize();
+          
+          console.log('📡 Starting all ServiceNow MCP servers...');
+          await manager.startAllServers();
+          
+          const status = manager.getServerList();
+          const running = status.filter((s: any) => s.status === 'running').length;
+          const total = status.length;
+          
+          console.log(chalk.green(`✅ Started ${running}/${total} MCP servers successfully!`));
+          console.log(chalk.blue('\n📋 MCP servers are now running in the background'));
+          console.log('🎯 They will be available when you run swarm commands');
+          
+        } catch (error) {
+          console.log(chalk.yellow('\n⚠️  Could not start MCP servers automatically'));
+          console.log('📝 You can start them manually with: ' + chalk.cyan('snow-flow mcp start'));
+        }
+      }
+      
+      console.log(chalk.blue.bold('\n🎯 Next steps:'));
+      console.log('1. Edit .env file with your ServiceNow credentials');
+      console.log('2. Run: ' + chalk.cyan('snow-flow auth login'));
+      console.log('3. Start developing: ' + chalk.cyan('snow-flow swarm "your objective"'));
+      console.log('\n📚 Full documentation: https://github.com/groeimetai/snow-flow');
+      
+      // Force exit to prevent hanging
+      process.exit(0);
+      
+    } catch (error) {
+      console.error(chalk.red('\n❌ Initialization failed:'), error);
+      process.exit(1);
+    }
+  });
+
+// Help command
+program
+  .command('help')
+  .description('Show detailed help information')
+  .action(() => {
+    console.log(`
+🚀 Snow-Flow v${VERSION} - ServiceNow Multi-Agent Development Framework
+
+📋 Available Commands:
+  swarm <objective>     Execute multi-agent orchestration
+  spawn <type>          Spawn specific agent types
+  status                Show system status
+  monitor               Real-time monitoring dashboard
+  memory <action>       Memory operations
+  auth <action>         Authentication management
+  mcp <action>          Manage ServiceNow MCP servers
+  help                  Show this help
+
+🎯 Example Usage:
+  snow-flow auth login --instance dev12345.service-now.com --client-id your-id --client-secret your-secret
+  snow-flow auth status
+  snow-flow mcp start   # Start MCP servers for Claude Code
+  snow-flow mcp status  # Check MCP server status
+  snow-flow swarm "create a widget for incident management"
+  snow-flow swarm "create approval flow"  # 🔧 Auto-detects Flow Designer and uses XML!
+  snow-flow spawn widget-builder --name "IncidentWidget"
+  snow-flow monitor --duration 120
+  snow-flow memory store "project" "incident_system"
+  snow-flow status
+
+🤖 Agent Types:
+  widget-builder       Create Service Portal widgets
+  workflow-designer    Design Flow Designer workflows
+  script-generator     Generate scripts and business rules
+  ui-builder          Create UI components
+  app-creator         Build complete applications
+
+⚙️  OAuth Configuration:
+  Set environment variables or use command line options:
+  - SNOW_INSTANCE: Your ServiceNow instance (e.g., dev12345.service-now.com)
+  - SNOW_CLIENT_ID: OAuth Client ID from ServiceNow
+  - SNOW_CLIENT_SECRET: OAuth Client Secret from ServiceNow
+  
+🔧 MCP Server Management:
+  - start        Start all or specific MCP servers
+  - stop         Stop all or specific MCP servers  
+  - restart      Restart all or specific MCP servers
+  - status       Show status of all MCP servers
+  - logs         View MCP server logs
+  - list         List all configured MCP servers
+
+  🔗 Live ServiceNow Integration:
+  - Create widgets directly in ServiceNow
+  - Execute workflows in real-time
+  - Test changes immediately in your instance
+
+🌐 More Info: https://github.com/groeimetai/snow-flow
+    `);
+  });
+
+// Helper functions for init command
+async function createDirectoryStructure(targetDir: string, force: boolean = false) {
+  const directories = [
+    '.claude', '.claude/commands', '.claude/commands/sparc', '.claude/configs',
+    '.swarm', '.swarm/sessions', '.swarm/agents',
+    '.snow-flow', '.snow-flow/queen', '.snow-flow/memory', '.snow-flow/data', '.snow-flow/queen-test', '.snow-flow/queen-advanced',
+    'memory', 'memory/agents', 'memory/sessions',
+    'coordination', 'coordination/memory_bank', 'coordination/subtasks',
+    'servicenow', 'servicenow/widgets', 'servicenow/workflows', 'servicenow/scripts',
+    'templates', 'templates/widgets', 'templates/workflows'
+  ];
+  
+  for (const dir of directories) {
+    const dirPath = join(targetDir, dir);
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+
+async function createBasicConfig(targetDir: string) {
+  const claudeConfig = {
+    version: VERSION,
+    name: 'snow-flow',
+    description: 'ServiceNow Multi-Agent Development Framework',
+    created: new Date().toISOString(),
+    features: {
+      swarmCoordination: true,
+      persistentMemory: true, // Queen uses JSON files, MCP tools use in-memory
+      serviceNowIntegration: true,
+      sparcModes: true
+    }
+  };
+  
+  const swarmConfig = {
+    version: VERSION,
+    topology: 'hierarchical',
+    maxAgents: 8,
+    memory: {
+      path: '.swarm/memory',
+      namespace: 'snow-flow'
+    }
+  };
+  
+  await fs.writeFile(join(targetDir, '.claude/config.json'), JSON.stringify(claudeConfig, null, 2));
+  await fs.writeFile(join(targetDir, '.swarm/config.json'), JSON.stringify(swarmConfig, null, 2));
+}
+
+async function createReadmeFiles(targetDir: string, force: boolean = false) {
+  // Only create README.md if it doesn't exist already
+  const readmePath = join(targetDir, 'README.md');
+  if (!existsSync(readmePath) || force) {
+    const mainReadme = `# Snow-Flow: Multi-Agent ServiceNow Development Platform 🚀
+
+Snow-Flow is a powerful multi-agent AI platform that revolutionizes ServiceNow development through intelligent automation, natural language processing, and autonomous deployment capabilities. Built with 11 specialized MCP (Model Context Protocol) servers, Snow-Flow enables developers to create, manage, and deploy ServiceNow artifacts using simple natural language commands.
+
+## 🆕 What's New in v1.1.51
+
+### 🎯 CRITICAL FIXES - All User Issues Resolved!
+- **ROOT CAUSE SOLVED**: Flow Designer validation failures completely eliminated
+- **JSON SCHEMA FLEXIBILITY**: Accepts both "steps" and "activities" arrays with auto-conversion
+- **DOCUMENTATION SYNC**: Init command now creates comprehensive CLAUDE.md (373 lines vs 15)
+- **COMPLETE GUIDE**: New users get full Snow-Flow development environment from day one
+
+### 🧠 Intelligent Error Recovery (v1.1.48-1.1.49)
+- **AUTOMATIC FALLBACKS**: Flow Designer → Business Rule conversion when deployment fails
+- **SMART SESSIONS**: Update Sets auto-create when none exist - no more "no active session" errors
+- **ZERO MANUAL WORK**: All systematic errors from user feedback now automatically handled
+- **COMPREHENSIVE TESTING**: Enhanced flow testing with Business Rule fallback detection
+
+### 🚀 Enhanced Swarm Command (v1.1.42+)
+Most intelligent features are now **enabled by default** - één command voor alles!
+- **DEFAULT TRUE**: \`--smart-discovery\`, \`--live-testing\`, \`--auto-deploy\`, \`--auto-rollback\`, \`--shared-memory\`, \`--progress-monitoring\`
+- **INTELLIGENT ORCHESTRATION**: Uses \`snow_orchestrate_development\` MCP tool automatically
+- **NO FLAGS NEEDED**: Just run \`snow-flow swarm "create widget"\` and everything works!
+
+### 🔍 Real-Time ServiceNow Integration (v1.1.41+)
+- **LIVE VALIDATION**: \`snow_validate_live_connection\` - real-time auth and permission checking
+- **SMART PREVENTION**: \`snow_discover_existing_flows\` - prevents duplicate flows
+- **LIVE TESTING**: \`snow_test_flow_execution\` - real flow testing in live instances
+- **BATCH VALIDATION**: \`batch_deployment_validator\` - comprehensive multi-artifact validation
+- **AUTO ROLLBACK**: \`deployment_rollback_manager\` - automatic rollback with backup creation
+
+## 🌟 Key Features
+
+### 🤖 11 Specialized MCP Servers
+Each server provides autonomous capabilities for different aspects of ServiceNow development:
+
+1. **Deployment MCP** - Autonomous widget and application deployment
+2. **Update Set MCP** - Professional change tracking and deployment management
+3. **Intelligent MCP** - AI-powered artifact discovery and editing
+4. **Graph Memory MCP** - Relationship tracking and impact analysis
+5. **Platform Development MCP** - Development workflow automation
+6. **Integration MCP** - Third-party system integration
+7. **Operations MCP** - Operations and monitoring management
+8. **Automation MCP** - Workflow and process automation
+9. **Security & Compliance MCP** - Security auditing and compliance
+10. **Reporting & Analytics MCP** - Data _analysis and reporting
+11. **Memory MCP** - Multi-agent coordination and todo management
+
+### 🎯 Core Capabilities
+
+- **Natural Language Processing**: Create complex ServiceNow artifacts using plain English/Dutch commands
+- **Intelligent Decision Making**: Automatically determines optimal architecture (flow vs subflow)
+- **Zero Configuration**: All values dynamically discovered from your ServiceNow instance
+- **Autonomous Deployment**: Direct deployment to ServiceNow with automatic error handling
+- **Update Set Management**: Professional change tracking like ServiceNow pros use
+- **Global Scope Strategy**: Intelligent scope selection with fallback mechanisms
+- **Multi-Agent Coordination**: Parallel execution for complex tasks
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Node.js 18+ and npm
+- ServiceNow instance with admin access
+- OAuth application configured in ServiceNow
+
+### Installation
+
+\`\`\`bash
+# Install Snow-Flow globally
+npm install -g snow-flow
+
+# Initialize Snow-Flow in your project directory
+snow-flow init
+\`\`\`
+
+#### Alternative: Install from source
+\`\`\`bash
+# Clone the repository
+git clone https://github.com/groeimetai/snow-flow.git
+cd snow-flow
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Link globally (optional)
+npm link
+\`\`\`
+
+### Configuration
+
+1. Create a \`.env\` file in the project root:
+\`\`\`env
+SNOW_INSTANCE=your-instance.service-now.com
+SNOW_CLIENT_ID=your-oauth-client-id
+SNOW_CLIENT_SECRET=your-oauth-client-secret
+SNOW_USERNAME=your-username
+SNOW_PASSWORD=your-password
+\`\`\`
+
+2. Set up OAuth in ServiceNow (see [SERVICENOW-OAUTH-SETUP.md](./SERVICENOW-OAUTH-SETUP.md))
+
+3. Authenticate with ServiceNow:
+\`\`\`bash
+snow-flow auth login
+\`\`\`
+
+### 🎯 MCP Server Activation (v1.1.25+)
+
+Snow-Flow now includes **automatic MCP server activation** for Claude Code! During initialization, you'll be prompted to automatically start Claude Code with all 11 MCP servers pre-loaded:
+
+\`\`\`bash
+snow-flow init
+
+# You'll see:
+# 🚀 Would you like to start Claude Code with MCP servers automatically? (Y/n)
+# Press Y to launch Claude Code with all MCP servers ready to use!
+\`\`\`
+
+The MCP servers are automatically:
+- ✅ Configured with correct paths for global npm installations
+- ✅ Registered in Claude Code's settings
+- ✅ Activated without manual approval steps
+- ✅ Ready to use immediately after initialization
+
+If you need to manually activate MCP servers later:
+\`\`\`bash
+# For Mac/Linux:
+claude --mcp-config .mcp.json .
+
+# For Windows:
+claude.exe --mcp-config .mcp.json .
+\`\`\`
+
+## 💡 Usage Examples
+
+### Create a Complex Flow with Natural Language
+\`\`\`bash
+snow-flow sparc "Create an approval workflow for iPhone 6 orders that notifies managers, creates tasks, and updates inventory"
+\`\`\`
+
+### Deploy a Widget Directly to ServiceNow
+\`\`\`bash
+snow-flow sparc "Create and deploy a widget that shows all critical incidents with real-time updates"
+\`\`\`
+
+### Start a Multi-Agent Swarm for Complex Projects
+\`\`\`bash
+# Most intelligent features are enabled by default!
+snow-flow swarm "Build a complete incident management system with dashboard, workflows, and notifications"
+
+# Default settings:
+# ✅ --smart-discovery (true) - Reuses existing artifacts
+# ✅ --live-testing (true) - Tests in real-time
+# ✅ --auto-deploy (true) - Deploys automatically (safe with update sets)
+# ✅ --auto-rollback (true) - Rollbacks on failures
+# ✅ --shared-memory (true) - Agents share context
+# ✅ --progress-monitoring (true) - Real-time status
+
+# Add --auto-permissions to enable automatic permission escalation
+snow-flow swarm "Create enterprise workflow" --auto-permissions
+
+# Disable specific features with --no- prefix
+snow-flow swarm "Test workflow" --no-auto-deploy --no-live-testing
+\`\`\`
+
+### Intelligent Artifact Discovery
+\`\`\`bash
+snow-flow sparc "Find and modify the approval workflow to add an extra approval step for orders over $1000"
+\`\`\`
+
+### Create Flows in Dutch
+\`\`\`bash
+snow-flow sparc "Maak een flow voor het automatisch toewijzen van incidenten aan de juiste groep op basis van categorie"
+\`\`\`
+
+## 🛠️ Advanced Features
+
+### Flow vs Subflow Intelligence
+Snow-Flow automatically analyzes your requirements and decides whether to create a main flow or break it into reusable subflows:
+- Complexity analysis
+- Reusability assessment
+- Performance optimization
+- Maintainability considerations
+
+### Update Set Management
+Professional change tracking just like ServiceNow developers use:
+\`\`\`bash
+# Create a new update set for your feature
+snow-flow sparc "Create update set for new approval features"
+
+# All subsequent changes are automatically tracked
+snow-flow sparc "Add approval widget to portal"
+\`\`\`
+
+### Global Scope Strategy
+Intelligent deployment scope selection:
+- Automatic permission validation
+- Fallback mechanisms for restricted environments
+- Environment-aware deployment (dev/test/prod)
+
+### Template Matching
+Recognizes common patterns and applies best practices:
+- Approval workflows
+- Fulfillment processes
+- Notification systems
+- Integration patterns
+
+## 🔧 New MCP Tools (v1.1.44+)
+
+### Catalog Item Search with Fuzzy Matching
+Find catalog items even when you don't know the exact name:
+\`\`\`javascript
+// In Claude Code with MCP tools
+snow_catalog_item_search({
+  query: "iPhone",          // Finds iPhone 6S, iPhone 7, etc.
+  fuzzy_match: true,       // Intelligent variations
+  category_filter: "mobile devices",
+  include_variables: true  // Get catalog variables
+});
+\`\`\`
+
+### Flow Testing with Mock Data
+Test flows without affecting production data:
+\`\`\`javascript
+snow_test_flow_with_mock({
+  flow_id: "equipment_provisioning_flow",
+  create_test_user: true,      // Auto-creates test user
+  mock_catalog_items: true,    // Creates test items
+  mock_catalog_data: [
+    {
+      name: "Test iPhone 6S",
+      price: "699.00"
+    }
+  ],
+  simulate_approvals: true,    // Auto-approves
+  cleanup_after_test: true     // Removes test data
+});
+\`\`\`
+
+### Direct Catalog-Flow Linking
+Link catalog items directly to flows for automated fulfillment:
+\`\`\`javascript
+snow_link_catalog_to_flow({
+  catalog_item_id: "iPhone 6S",
+  flow_id: "mobile_provisioning_flow",
+  link_type: "flow_catalog_process",  // Modern approach
+  variable_mapping: [
+    {
+      catalog_variable: "phone_model",
+      flow_input: "device_type"
+    },
+    {
+      catalog_variable: "user_department",
+      flow_input: "department"
+    }
+  ],
+  trigger_condition: 'current.stage == "request_approved"',
+  execution_options: {
+    run_as: "user",    // 🔒 SEC-001 FIX: Default to 'user' to prevent privilege escalation
+    wait_for_completion: true
+  },
+  test_link: true  // Creates test request
+});
+\`\`\`
+
+### Bulk Deployment
+Deploy multiple artifacts in a single transaction:
+\`\`\`javascript
+snow_bulk_deploy({
+  artifacts: [
+    { type: "widget", data: widgetData },
+    { type: "flow", data: flowData },
+    { type: "script", data: scriptData }
+  ],
+  transaction_mode: true,  // All-or-nothing deployment
+  parallel: true,         // Deploy simultaneously
+  dry_run: false
+});
+\`\`\`
+
+## 📁 Project Structure
+
+\`\`\`
+snow-flow/
+├── src/
+│   ├── mcp/                    # 11 MCP server implementations
+│   ├── orchestrator/           # Flow composition and intelligence
+│   ├── strategies/             # Deployment and scope strategies
+│   ├── api/                    # ServiceNow API integration
+│   ├── managers/               # Resource and scope management
+│   └── utils/                  # Utilities and helpers
+├── .snow-flow/                 # Snow-Flow configuration
+├── .claude/                    # Claude configuration
+├── memory/                     # Persistent agent memory
+└── coordination/               # Multi-agent coordination
+\`\`\`
+
+## 🔧 Development Commands
+
+\`\`\`bash
+# Run tests
+npm test
+
+# Run linting
+npm run lint
+
+# Type checking
+npm run typecheck
+
+# Development mode
+npm run dev
+
+# Build for production
+npm run build
+\`\`\`
+
+## 📚 Documentation
+
+- [MCP Server Documentation](./MCP_SERVERS.md) - Detailed info on all 11 MCP servers
+- [OAuth Setup Guide](./SERVICENOW-OAUTH-SETUP.md) - ServiceNow OAuth configuration
+- [Update Set Guide](./UPDATE_SET_DEPLOYMENT_GUIDE.md) - Professional change management
+- [API Integration Guide](./API_INTEGRATION_GUIDE.md) - ServiceNow API details
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our contributing guidelines (coming soon).
+
+## 🔒 Security
+
+- All credentials stored securely in environment variables
+- OAuth 2.0 authentication with ServiceNow
+- No hardcoded values - everything discovered dynamically
+- Secure token management with automatic refresh
+
+## 🎯 Use Cases
+
+### For ServiceNow Developers
+- Rapidly prototype flows and workflows
+- Automate repetitive development tasks
+- Ensure consistency across implementations
+- Reduce development time by 80%
+
+### For ServiceNow Architects
+- Validate architectural decisions
+- Ensure best practices are followed
+- Analyze impact of changes
+- Optimize performance and maintainability
+
+### For ServiceNow Administrators
+- Quick deployments and updates
+- Professional change tracking
+- Automated testing and validation
+- Simplified migration between instances
+
+## 🚦 Roadmap
+
+- [ ] Visual flow designer integration
+- [ ] Enhanced Neo4j graph visualization
+- [ ] Multi-instance synchronization
+- [ ] AI-powered code review
+- [ ] Automated testing framework
+- [ ] Performance optimization recommendations
+
+## 🆕 What's New in v1.1.25
+
+### Automatic MCP Server Activation 🎯
+- **Interactive Prompt**: During \`snow-flow init\`, you're now prompted to automatically start Claude Code with all MCP servers
+- **Zero Manual Steps**: No more manual MCP approval in Claude Code - servers load automatically using \`claude --mcp-config\`
+- **Cross-Platform Support**: Works on Mac, Linux, and Windows with platform-specific activation scripts
+- **Instant Availability**: All 11 ServiceNow MCP servers are immediately available in Claude Code after initialization
+
+### Previous Updates
+- **v1.1.24**: Added \`snow-flow mcp debug\` command for troubleshooting MCP configurations
+- **v1.1.23**: Fixed .npmignore to include essential .claude configuration files
+- **v1.1.22**: Verified global npm installation correctly registers all MCP servers
+- **v1.1.20**: Added enabledMcpjsonServers to ensure MCP visibility in Claude Code
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+Built with the power of Claude AI and the ServiceNow platform. Special thanks to the ServiceNow developer community for inspiration and best practices.
+
+---
+
+**Ready to revolutionize your ServiceNow development?** Start with \`snow-flow init\` and experience the future of ServiceNow automation! 🚀
+`;
+
+    await fs.writeFile(readmePath, mainReadme);
+  }
+  
+  // Create sub-directory READMEs
+  await fs.writeFile(join(targetDir, 'memory/agents/README.md'), '# Agent Memory\n\nThis directory contains persistent memory for ServiceNow agents.');
+  await fs.writeFile(join(targetDir, 'servicenow/README.md'), '# ServiceNow Artifacts\n\nThis directory contains generated ServiceNow development artifacts.');
+}
+
+
+// Helper functions
+
+async function copyCLAUDEmd(targetDir: string, force: boolean = false) {
+  let claudeMdContent = '';
+  try {
+    // First try to find the CLAUDE.md in the source directory (for global installs)
+    const sourceClaudeFiles = [
+      // Try the project root (when running from dist/)
+      join(__dirname, '..', 'CLAUDE.md'),
+      // Try when running directly from src/
+      join(__dirname, 'CLAUDE.md'), 
+      // Try npm global installation paths  
+      join(__dirname, '..', '..', '..', 'CLAUDE.md'),
+      join(__dirname, '..', '..', '..', '..', 'CLAUDE.md'),
+      // Try current working directory as fallback
+      join(process.cwd(), 'CLAUDE.md')
+    ];
+    
+    let foundSource = false;
+    
+    for (const sourcePath of sourceClaudeFiles) {
+      try {
+        claudeMdContent = await fs.readFile(sourcePath, 'utf8');
+        foundSource = true;
+        console.log(`✅ Found CLAUDE.md source at: ${sourcePath}`);
+        break;
+      } catch {
+        // Continue to next path
+      }
+    }
+    
+    if (!foundSource) {
+      // Use Snow-Flow specific CLAUDE.md content
+      console.log('⚠️  Could not find CLAUDE.md source, creating minimal version');
+      claudeMdContent = `# Snow-Flow Development with Claude Code
+
+## 🚨 CRITICAL: MCP-FIRST WORKFLOW (READ THIS FIRST!)
+
+**Snow-flow's core value is REAL ServiceNow integration through MCP tools. NEVER work in offline mode!**
+
+### ⚠️ MANDATORY WORKFLOW - NO EXCEPTIONS
+
+**Every ServiceNow task MUST start with this sequence:**
+
+\`\`\`javascript
+// 1. MANDATORY: Pre-flight authentication check
+const authCheck = await snow_validate_live_connection({ test_level: "permissions" });
+if (!authCheck.success) {
+  // STOP! Fix authentication first
+  return authenticationError(authCheck.error);
+}
+
+// 2. MANDATORY: Discovery before creation
+const discovery = await snow_find_artifact({ 
+  query: "your objective",
+  type: "widget|flow|script|any" 
+});
+
+// 3. MANDATORY: Real ServiceNow deployment
+const deployment = await snow_deploy({
+  type: "widget|application",  // Note: flow removed in v1.4.0+
+  config: { /* your config */ },
+  auto_update_set: true  // Always track changes
+});
+
+// 4. MANDATORY: Track in Update Set
+await snow_update_set_add_artifact({
+  type: deployment.type,
+  sys_id: deployment.result.sys_id,
+  name: deployment.result.name
+});
+\`\`\`
+
+### 🚫 FORBIDDEN ACTIONS
+
+**THESE ACTIONS ARE BANNED - NEVER DO THESE:**
+
+❌ **Creating local files** without MCP check first  
+❌ **Generating mock data** instead of using MCP tools  
+❌ **Working in "offline mode"** when ServiceNow is available  
+❌ **Skipping authentication validation**  
+❌ **Planning mode** without trying MCP tools first
+
+### ✅ CORRECT: MCP-First Decision Tree
+
+\`\`\`
+User Request → ALWAYS START HERE:
+    ↓
+1. snow_validate_live_connection()
+    ↓
+   SUCCESS? → Continue to Step 2
+    ↓
+   FAILURE? → Fix auth: snow_auth_diagnostics()
+              Then guide user: "snow-flow auth login"
+              STOP until auth works
+    ↓
+2. snow_find_artifact() // Check if exists
+    ↓
+   FOUND? → Ask: "Reuse existing or create new?"
+    ↓
+   NOT FOUND? → Continue to Step 3
+    ↓
+3. snow_deploy() // Real deployment to ServiceNow
+    ↓
+   SUCCESS? → Step 4: Track in Update Set
+    ↓
+   FAILURE? → Use fallback strategies
+    ↓
+4. snow_update_set_add_artifact() // Always track
+    ↓
+   DONE! ✅
+\`\`\`
+
+## 🚀 Snow-Flow Swarm Command - MCP-Orchestrated Multi-Agent Intelligence
+
+**The Swarm system is MCP-native and ALWAYS uses ServiceNow tools first!**
+
+### 🧠 Queen Agent with Parallel Execution (v1.4.0+)
+- Automatically spawns 6+ specialized agents for widget development
+- Achieves proven 2.8x speedup through intelligent parallel execution
+- All agents coordinate through Snow-Flow's memory system
+- Every agent uses MCP tools directly - no offline mode
+
+## 🛠️ Complete ServiceNow MCP Tools Reference
+
+### Discovery & Search Tools
+\`\`\`javascript
+// Find any ServiceNow artifact using natural language
+snow_find_artifact({
+  query: "the widget that shows incidents on homepage",
+  type: "widget" // or "flow", "script", "application", "any"
+});
+
+// Search catalog items with fuzzy matching
+snow_catalog_item_search({
+  query: "laptop",
+  fuzzy_match: true,        // Finds variations: notebook, MacBook, etc.
+  category_filter: "hardware",
+  include_variables: true   // Get catalog variables too
+});
+
+// Direct sys_id lookup (faster than search)
+snow_get_by_sysid({
+  sys_id: "<artifact_sys_id>",
+  table: "sp_widget"
+});
+\`\`\`
+
+### Flow Development Tools
+\`\`\`javascript
+// Create flows from natural language
+snow_create_flow({
+  instruction: "create a flow that sends email when incident priority is high",
+  deploy_immediately: true  // Automatically deploys XML to ServiceNow
+});
+
+// Test flows with mock data
+snow_test_flow_with_mock({
+  flow_id: "incident_notification_flow",
+  create_test_user: true,
+  mock_catalog_items: true,
+  test_inputs: {
+    priority: "1",
+    category: "hardware"
+  },
+  simulate_approvals: true
+});
+
+// Link catalog items to flows
+snow_link_catalog_to_flow({
+  catalog_item_id: "New Laptop Request",
+  flow_id: "laptop_provisioning_flow",
+  link_type: "flow_catalog_process",
+  variable_mapping: [
+    {
+      catalog_variable: "laptop_model",
+      flow_input: "equipment_type"
+    }
+  ]
+});
+\`\`\`
+
+### Widget Development Tools
+\`\`\`javascript
+// Deploy widgets with automatic validation
+snow_deploy_widget({
+  name: "incident_dashboard",
+  title: "Incident Dashboard",
+  template: htmlContent,
+  css: cssContent,
+  client_script: clientJS,
+  server_script: serverJS,
+  demo_data: { incidents: [...] }
+});
+
+// Preview and test widgets
+snow_preview_widget({
+  widget_id: "incident_dashboard",
+  check_dependencies: true
+});
+
+snow_widget_test({
+  widget_id: "incident_dashboard",
+  test_scenarios: [
+    {
+      name: "Load with no data",
+      server_data: { incidents: [] }
+    }
+  ]
+});
+\`\`\`
+
+### Bulk Operations
+\`\`\`javascript
+// Deploy multiple artifacts at once
+snow_bulk_deploy({
+  artifacts: [
+    { type: "widget", data: widgetData },
+    { type: "flow", data: flowData },
+    { type: "script", data: scriptData }
+  ],
+  transaction_mode: true,     // All or nothing
+  parallel: true,            // Deploy simultaneously
+  dry_run: false
+});
+\`\`\`
+
+### Intelligent Analysis
+\`\`\`javascript
+// Analyze incidents with AI
+snow_analyze_incident({
+  incident_id: "INC0010001",
+  include_similar: true,
+  suggest_resolution: true
+});
+
+// Pattern analysis
+snow_pattern__analysis({
+  analysis_type: "incident_patterns",
+  timeframe: "month"
+});
+\`\`\`
+
+## ⚡ Performance Optimization
+
+### Parallel Execution Patterns
+\`\`\`javascript
+// Execute multiple searches concurrently
+Promise.all([
+  snow_find_artifact({ query: "incident widget" }),
+  snow_catalog_item_search({ query: "laptop" }),
+  snow_query_table({ table: "incident", query: "priority=1" })  // Universal query tool
+]);
+\`\`\`
+
+### Batch File Operations
+\`\`\`javascript
+// Read multiple files in one operation
+MultiRead([
+  "/path/to/widget.html",
+  "/path/to/widget.css",
+  "/path/to/widget.js"
+]);
+\`\`\`
+
+## 📝 Workflow Guidelines
+
+### Standard Development Flow
+1. **Discovery Phase**: Use search tools to find existing artifacts
+2. **Planning Phase**: Use TodoWrite to plan all tasks
+3. **Development Phase**: Launch agents concurrently
+4. **Testing Phase**: Use mock testing tools
+5. **Deployment Phase**: Use bulk deploy with validation
+
+### Error Recovery Patterns
+\`\`\`javascript
+// Always implement rollback strategies
+if (deployment.failed) {
+  snow_deployment_rollback_manager({
+    update_set_id: deployment.update_set,
+    restore_point: deployment.backup_id
+  });
+}
+\`\`\`
+
+## 🔧 Advanced Configuration
+
+## Build Commands
+- \`npm run build\`: Build the project
+- \`npm run test\`: Run the full test suite
+- \`npm run lint\`: Run ESLint and format checks
+- \`npm run typecheck\`: Run TypeScript type checking
+
+## Snow-Flow Commands
+- \`snow-flow init\`: Initialize project with MCP servers and SPARC environment and SPARC environment
+- \`snow-flow auth login\`: Authenticate with ServiceNow OAuth
+- \`snow-flow swarm "<objective>"\`: Start multi-agent swarm - één command voor alles!
+- \`snow-flow sparc <mode> "<task>"\`: Run specific SPARC mode
+
+## Enhanced Swarm Command (v1.1.41+)
+The swarm command now includes intelligent features that are **enabled by default**:
+
+\`\`\`bash
+# Simple usage - ALL autonomous systems enabled by default!
+snow-flow swarm "create incident management dashboard"
+
+# Disable specific autonomous systems if needed
+snow-flow swarm "create simple widget" --no-autonomous-cost-optimization --no-autonomous-compliance
+
+# Disable ALL autonomous systems
+snow-flow swarm "basic development only" --no-autonomous-all
+
+# Force enable all (overrides any --no- flags)
+snow-flow swarm "full orchestration mode" --autonomous-all
+\`\`\`
+
+### 🤖 NEW: Autonomous Systems (v1.3.26+) - **ENABLED BY DEFAULT!**
+True orchestration with zero manual intervention - all systems active unless disabled:
+
+- ✅ **Documentation**: Self-documenting system (auto-generates and updates docs)
+- ✅ **Cost Optimization**: AI-driven cost management with auto-optimization  
+- ✅ **Compliance**: Multi-framework compliance monitoring with auto-remediation
+- ✅ **Self-Healing**: Predictive failure detection with automatic recovery
+
+**Disable Options**:
+- \`--no-autonomous-documentation\`: Disable documentation system
+- \`--no-autonomous-cost-optimization\`: Disable cost optimization
+- \`--no-autonomous-compliance\`: Disable compliance monitoring
+- \`--no-autonomous-healing\`: Disable self-healing
+- \`--no-autonomous-all\`: Disable ALL autonomous systems
+
+**Force Options**:
+- \`--autonomous-all\`: Force enable all (overrides --no- flags)
+
+**Perfect Orchestrator**: Systems work autonomously, make intelligent decisions, and continuously improve - no manual intervention needed!
+
+### Default Settings (no flags needed):
+- ✅ \`--smart-discovery\` - Automatically discovers and reuses existing artifacts
+- ✅ \`--live-testing\` - Tests in real-time on your ServiceNow instance
+- ✅ \`--auto-deploy\` - Deploys automatically (safe with update sets)
+- ✅ \`--auto-rollback\` - Automatically rollbacks on failures
+- ✅ \`--shared-memory\` - All agents share context and coordination
+- ✅ \`--progress-monitoring\` - Real-time progress tracking
+- ❌ \`--auto-permissions\` - Disabled by default (enable with flag for automatic role elevation)
+
+### Advanced Usage:
+\`\`\`bash
+# Enable automatic permission escalation
+snow-flow swarm "create global workflow" --auto-permissions
+
+# Disable specific features
+snow-flow swarm "test widget" --no-auto-deploy --no-live-testing
+
+# Full control
+snow-flow swarm "complex integration" \\
+  --max-agents 8 \\
+  --strategy development \\
+  --mode distributed \\
+  --parallel \\
+  --auto-permissions
+\`\`\`
+
+## New MCP Tools (v1.1.44+)
+
+### Catalog Item Search
+Find catalog items with intelligent fuzzy matching:
+\`\`\`javascript
+snow_catalog_item_search({
+  query: "iPhone",          // Will find iPhone 6S, iPhone 7, etc.
+  fuzzy_match: true,        // Enable intelligent variations
+  include_variables: true   // Include catalog variables
+})
+\`\`\`
+
+### Flow Testing with Mock Data
+Test flows without real data:
+\`\`\`javascript
+snow_test_flow_with_mock({
+  flow_id: "equipment_provisioning_flow",
+  create_test_user: true,      // Creates test user
+  mock_catalog_items: true,    // Creates test catalog items
+  simulate_approvals: true,    // Auto-approves during test
+  cleanup_after_test: true     // Removes test data after
+})
+\`\`\`
+
+### Direct Catalog-Flow Linking
+Link catalog items directly to flows:
+\`\`\`javascript
+snow_link_catalog_to_flow({
+  catalog_item_id: "iPhone 6S",
+  flow_id: "mobile_provisioning_flow",
+  link_type: "flow_catalog_process",  // Modern approach
+  variable_mapping: [
+    {
+      catalog_variable: "phone_model",
+      flow_input: "device_type"
+    }
+  ],
+  test_link: true  // Creates test request
+})
+\`\`\`
+
+### OAuth Configuration
+\`\`\`env
+# .env file
+SNOW_INSTANCE=dev123456
+SNOW_CLIENT_ID=your_oauth_client_id
+SNOW_CLIENT_SECRET=your_oauth_client_secret
+SNOW_USERNAME=admin
+SNOW_PASSWORD=admin_password
+\`\`\`
+
+### Update Set Management
+\`\`\`javascript
+// Smart update set creation
+snow_smart_update_set({
+  name: "Auto-generated for widget development",
+  detect_context: true,  // Auto-detects what you're working on
+  auto_switch: true     // Switches when context changes
+});
+\`\`\`
+
+## 🎯 Quick Start
+1. \`snow-flow init\` - Initialize project with MCP servers and SPARC environment and SPARC environment
+2. Configure ServiceNow credentials in .env file
+3. \`snow-flow auth login\` - Authenticate with ServiceNow OAuth
+4. \`snow-flow swarm "create a widget for incident management"\` - Everything automatic!
+
+## 💡 Important Notes
+
+### Do's
+- ✅ Use TodoWrite extensively for task tracking
+- ✅ Batch MCP tool calls for performance
+- ✅ Store important data in Memory for coordination
+- ✅ Test with mock data before deploying
+- ✅ Work within Update Sets for safety
+- ✅ Use fuzzy search for finding artifacts
+
+### Don'ts
+- ❌ Don't make sequential tool calls when batch is possible
+- ❌ Don't hardcode credentials or sys_ids
+- ❌ Don't deploy without testing
+- ❌ Don't ignore OAuth permission errors
+- ❌ Don't create artifacts without checking if they exist
+
+## 🚀 Performance Benchmarks
+
+With concurrent execution and batch operations:
+- **Widget Development**: 3x faster than sequential
+- **Flow Creation**: 2.5x faster with parallel validation
+- **Bulk Deployment**: Up to 5x faster with parallel mode
+- **Search Operations**: 4x faster with concurrent queries
+
+## 📚 Additional Resources
+
+### MCP Server Documentation
+- **servicenow-deployment**: Widget, flow, and application deployment
+- **servicenow-intelligent**: Smart search and artifact discovery
+- **servicenow-operations**: Incident management and catalog operations
+- **servicenow-platform-development**: Scripts, rules, and policies
+
+### SPARC Modes
+- \`orchestrator\`: Coordinates complex multi-step tasks
+- \`coder\`: Focused code implementation
+- \`researcher\`: Deep _analysis and discovery
+- \`tester\`: Comprehensive testing strategies
+- \`architect\`: System design and architecture
+
+---
+
+This is a minimal CLAUDE.md file. The full documentation should be available in your Snow-Flow installation.
+
+## Quick Start
+1. \`snow-flow init\` - Initialize project with MCP servers and SPARC environment and SPARC environment
+2. Configure ServiceNow credentials in .env file  
+3. \`snow-flow auth login\` - Authenticate with ServiceNow OAuth
+4. \`snow-flow swarm "create a widget for incident management"\` - Everything automatic!
+
+For full documentation, visit: https://github.com/groeimetai/snow-flow
+`;
+    }
+    
+    const claudeMdPath = join(targetDir, 'CLAUDE.md');
+    try {
+      await fs.access(claudeMdPath);
+      if (force) {
+        console.log('⚠️  CLAUDE.md already exists, overwriting with --force flag');
+        await fs.writeFile(claudeMdPath, claudeMdContent);
+      } else {
+        console.log('⚠️  CLAUDE.md already exists, skipping (use --force to overwrite)');
+      }
+    } catch {
+      await fs.writeFile(claudeMdPath, claudeMdContent);
+    }
+  } catch (error) {
+    console.log('⚠️  Error copying CLAUDE.md, creating Snow-Flow specific version');
+    // Snow-Flow specific fallback content
+    const claudeMdFallback = `# Snow-Flow Development with Claude Code
+
+## 🚨 CRITICAL: MCP-FIRST WORKFLOW (READ THIS FIRST!)
+
+**Snow-flow's core value is REAL ServiceNow integration through MCP tools. NEVER work in offline mode!**
+
+### ⚠️ MANDATORY WORKFLOW - NO EXCEPTIONS
+
+**Every ServiceNow task MUST start with this sequence:**
+
+\`\`\`javascript
+// 1. MANDATORY: Pre-flight authentication check
+const authCheck = await snow_validate_live_connection({ test_level: "permissions" });
+if (!authCheck.success) {
+  // STOP! Fix authentication first
+  return authenticationError(authCheck.error);
+}
+
+// 2. MANDATORY: Discovery before creation
+const discovery = await snow_find_artifact({ 
+  query: "your objective",
+  type: "widget|flow|script|any" 
+});
+
+// 3. MANDATORY: Real ServiceNow deployment
+const deployment = await snow_deploy({
+  type: "widget|application",  // Note: flow removed in v1.4.0+
+  config: { /* your config */ },
+  auto_update_set: true  // Always track changes
+});
+
+// 4. MANDATORY: Track in Update Set
+await snow_update_set_add_artifact({
+  type: deployment.type,
+  sys_id: deployment.result.sys_id,
+  name: deployment.result.name
+});
+\`\`\`
+
+### 🚫 FORBIDDEN ACTIONS
+
+**THESE ACTIONS ARE BANNED - NEVER DO THESE:**
+
+❌ **Creating local files** without MCP check first  
+❌ **Generating mock data** instead of using MCP tools  
+❌ **Working in "offline mode"** when ServiceNow is available  
+❌ **Skipping authentication validation**  
+❌ **Planning mode** without trying MCP tools first
+
+### ✅ CORRECT: MCP-First Decision Tree
+
+\`\`\`
+User Request → ALWAYS START HERE:
+    ↓
+1. snow_validate_live_connection()
+    ↓
+   SUCCESS? → Continue to Step 2
+    ↓
+   FAILURE? → Fix auth: snow_auth_diagnostics()
+              Then guide user: "snow-flow auth login"
+              STOP until auth works
+    ↓
+2. snow_find_artifact() // Check if exists
+    ↓
+   FOUND? → Ask: "Reuse existing or create new?"
+    ↓
+   NOT FOUND? → Continue to Step 3
+    ↓
+3. snow_deploy() // Real deployment to ServiceNow
+    ↓
+   SUCCESS? → Step 4: Track in Update Set
+    ↓
+   FAILURE? → Use fallback strategies
+    ↓
+4. snow_update_set_add_artifact() // Always track
+    ↓
+   DONE! ✅
+\`\`\`
+
+## 🚀 Snow-Flow Swarm Command - MCP-Orchestrated Multi-Agent Intelligence
+
+**The Swarm system is MCP-native and ALWAYS uses ServiceNow tools first!**
+
+### 🧠 Queen Agent with Parallel Execution (v1.4.0+)
+- Automatically spawns 6+ specialized agents for widget development
+- Achieves proven 2.8x speedup through intelligent parallel execution
+- All agents coordinate through Snow-Flow's memory system
+- Every agent uses MCP tools directly - no offline mode
+
+### Swarm Command Examples
+\`\`\`bash
+# Simple widget creation
+snow-flow swarm "create incident dashboard widget"
+
+# Complex development
+snow-flow swarm "build employee onboarding portal with approval workflows"
+
+# With specific options
+snow-flow swarm "create service catalog item" --no-auto-deploy --monitor
+\`\`\`
+
+## 🛠️ Complete ServiceNow MCP Tools Reference
+
+### Discovery & Search Tools
+\`\`\`javascript
+// Find any ServiceNow artifact using natural language
+snow_find_artifact({
+  query: "the widget that shows incidents on homepage",
+  type: "widget" // or "flow", "script", "application", "any"
+});
+
+// Search catalog items with fuzzy matching
+snow_catalog_item_search({
+  query: "laptop",
+  fuzzy_match: true,        // Finds variations: notebook, MacBook, etc.
+  include_variables: true   // Include catalog variables
+});
+
+// Comprehensive search across all tables
+snow_comprehensive_search({
+  query: "approval",
+  include_inactive: false
+});
+\`\`\`
+
+### Deployment Tools
+\`\`\`javascript
+// Universal deployment tool
+snow_deploy({
+  type: "widget",
+  config: {
+    name: "Incident Dashboard",
+    template: "<html>...</html>",
+    css: "/* styles */",
+    server_script: "// server code",
+    client_script: "// client code"
+  },
+  auto_update_set: true
+});
+
+// Bulk deployment
+snow_bulk_deploy({
+  artifacts: [...],
+  transaction_mode: true,
+  rollback_on_error: true
+});
+\`\`\`
+
+### Update Set Management
+\`\`\`javascript
+// Ensure active Update Set
+snow_ensure_active_update_set({
+  context: "Widget development"
+});
+
+// Track artifacts
+snow_update_set_add_artifact({
+  type: "widget",
+  sys_id: "abc123",
+  name: "My Widget"
+});
+
+// Preview changes
+snow_update_set_preview({
+  update_set_id: "current"
+});
+\`\`\`
+
+### Testing Tools
+\`\`\`javascript
+// Test flows with mock data
+snow_test_flow_with_mock({
+  flow_id: "equipment_provisioning_flow",
+  create_test_user: true,
+  mock_catalog_items: true,
+  simulate_approvals: true,
+  cleanup_after_test: true
+});
+
+// Link catalog to flow
+snow_link_catalog_to_flow({
+  catalog_item_id: "iPhone 6S",
+  flow_id: "mobile_provisioning_flow",
+  test_link: true
+});
+\`\`\`
+
+## 📋 Essential Patterns
+
+### Authentication Handling
+\`\`\`javascript
+// Always handle auth failures gracefully
+if (error.includes('401') || error.includes('403')) {
+  // Guide user to fix authentication
+  console.log('Run: snow-flow auth login');
+  console.log('Check .env file for credentials');
+  // STOP - don't continue without auth
+}
+\`\`\`
+
+### Error Recovery
+\`\`\`javascript
+// Implement fallback strategies
+if (deployment.failed) {
+  // Try global scope
+  const globalAttempt = await snow_deploy({ 
+    ...config, 
+    scope_preference: 'global' 
+  });
+  
+  if (globalAttempt.failed) {
+    // Provide manual instructions
+    return createManualStepsGuide(config, error);
+  }
+}
+\`\`\`
+
+## 🔧 Configuration
+
+### Build Commands
+- \`npm run build\`: Build the project
+- \`npm run test\`: Run the full test suite
+- \`npm run lint\`: Run ESLint and format checks
+- \`npm run typecheck\`: Run TypeScript type checking
+
+### Snow-Flow Commands
+- \`snow-flow init\`: Initialize project with MCP servers and SPARC environment
+- \`snow-flow auth login\`: Authenticate with ServiceNow
+- \`snow-flow swarm "<objective>"\`: Execute multi-agent development
+- \`snow-flow mcp start\`: Start MCP servers manually
+
+### Environment Setup
+\`\`\`bash
+# .env file
+SNOW_INSTANCE=dev123456
+SNOW_CLIENT_ID=your_oauth_client_id
+SNOW_CLIENT_SECRET=your_oauth_client_secret
+\`\`\`
+
+## 💡 Best Practices
+
+### DO's
+✅ Always use \`snow_validate_live_connection()\` first  
+✅ Check for existing artifacts with \`snow_find_artifact()\`  
+✅ Use Update Sets for all changes  
+✅ Test with mock data before production  
+✅ Handle errors gracefully with fallbacks  
+
+### DON'Ts
+❌ Don't create local files first  
+❌ Don't skip authentication  
+❌ Don't hardcode sys_ids or credentials  
+❌ Don't work in offline mode  
+❌ Don't deploy without testing  
+
+## 🎯 Quick Start
+1. \`snow-flow init\` - Initialize project with MCP servers and SPARC environment
+2. Configure ServiceNow credentials in .env file  
+3. \`snow-flow auth login\` - Authenticate with ServiceNow
+4. \`snow-flow swarm "create a widget for incident management"\` - Everything automatic!
+
+For full documentation, visit: https://github.com/groeimetai/snow-flow
+`;
+    const claudeMdPath = join(targetDir, 'CLAUDE.md');
+    if (force || !existsSync(claudeMdPath)) {
+      await fs.writeFile(claudeMdPath, claudeMdFallback);
+    }
+  }
+}
+
+async function createEnvFile(targetDir: string, force: boolean = false) {
+  // Read content from .env.template file
+  let envContent: string;
+  
+  try {
+    // Try to read from the project's .env.template file
+    const templatePath = join(__dirname, '..', '.env.template');
+    envContent = await fs.readFile(templatePath, 'utf-8');
+    console.log('📋 Using .env.template for configuration');
+  } catch (error) {
+    // If template not found, try alternative locations
+    try {
+      const alternativePath = join(process.cwd(), '.env.template');
+      envContent = await fs.readFile(alternativePath, 'utf-8');
+      console.log('📋 Using .env.template from current directory');
+    } catch (fallbackError) {
+      console.warn('⚠️  Could not find .env.template file, using embedded minimal version');
+      // Last resort: use embedded minimal version with v3.0.1 timeout config
+      envContent = `# ServiceNow Configuration
+# ===========================================
+
+# ServiceNow Instance URL (without https://)
+# Example: dev12345.service-now.com
+SNOW_INSTANCE=your-instance.service-now.com
+
+# OAuth Client ID from ServiceNow Application Registry
+SNOW_CLIENT_ID=your-oauth-client-id
+
+# OAuth Client Secret from ServiceNow Application Registry
+SNOW_CLIENT_SECRET=your-oauth-client-secret
+
+# ===========================================
+# Snow-Flow Configuration
+# ===========================================
+
+# Enable debug logging (true/false)
+SNOW_FLOW_DEBUG=false
+
+# Default coordination strategy
+SNOW_FLOW_STRATEGY=development
+
+# Maximum number of agents
+SNOW_FLOW_MAX_AGENTS=5
+
+# ===========================================
+# Claude Code API Integration (30 minutes)
+# ===========================================
+# API timeout for Claude Code integration - 30 minutes
+# This ensures Snow-Flow works smoothly with Claude Code's extended operation timeouts
+API_TIMEOUT_MS=1800000
+
+# ===========================================
+# Timeout Configuration (v3.0.1+)
+# ===========================================
+# IMPORTANT: Snow-Flow has NO TIMEOUTS by default for maximum reliability.
+# Operations run until completion. Only set timeouts if you specifically need them.
+# All timeout values below are COMMENTED OUT - uncomment only what you need.
+
+# Memory Operations (TodoWrite, etc.)
+# MCP_MEMORY_TIMEOUT=30000      # 30 seconds
+# MCP_MEMORY_TIMEOUT=60000      # 1 minute
+# MCP_MEMORY_TIMEOUT=120000     # 2 minutes
+
+# ServiceNow API Operations
+# SNOW_API_TIMEOUT=60000        # 1 minute - quick operations
+# SNOW_API_TIMEOUT=180000       # 3 minutes - standard operations
+# SNOW_API_TIMEOUT=300000       # 5 minutes - complex queries
+
+# Deployment Operations
+# SNOW_DEPLOYMENT_TIMEOUT=300000  # 5 minutes - simple deployments
+# SNOW_DEPLOYMENT_TIMEOUT=600000  # 10 minutes - complex widgets
+
+# MCP transport timeout (should be higher than SNOW_DEPLOYMENT_TIMEOUT if both set)
+# MCP_DEPLOYMENT_TIMEOUT=360000   # 6 minutes
+# MCP_DEPLOYMENT_TIMEOUT=720000   # 12 minutes
+`;
+    }
+  }
+
+  const envFilePath = join(targetDir, '.env');
+  
+  // Check if .env already exists
+  try {
+    await fs.access(envFilePath);
+    if (force) {
+      console.log('⚠️  .env file already exists, overwriting with --force flag');
+      await fs.writeFile(envFilePath, envContent);
+      console.log('✅ .env file overwritten successfully');
+    } else {
+      console.log('⚠️  .env file already exists, creating .env.example template instead');
+      console.log('📝 To overwrite: use --force flag or delete existing .env file');
+      await fs.writeFile(join(targetDir, '.env.example'), envContent);
+      console.log('✅ .env.example template created');
+    }
+  } catch {
+    // .env doesn't exist, create it
+    console.log('📄 Creating new .env file...');
+    await fs.writeFile(envFilePath, envContent);
+    console.log('✅ .env file created successfully');
+  }
+}
+
+async function appendToEnvFile(targetDir: string, content: string) {
+  const envFilePath = join(targetDir, '.env');
+  await fs.appendFile(envFilePath, content);
+}
+
+async function checkNeo4jAvailability(): Promise<boolean> {
+  const { execSync } = require('child_process');
+  
+  try {
+    // Check if Neo4j is installed
+    execSync('which neo4j', { stdio: 'pipe' });
+    
+    // Check if Neo4j is running
+    try {
+      execSync('neo4j status', { stdio: 'pipe' });
+      return true;
+    } catch {
+      // Neo4j is installed but not running
+      console.log('ℹ️  Neo4j is installed but not running. Start with: neo4j start');
+      return false;
+    }
+  } catch {
+    // Neo4j is not installed
+    return false;
+  }
+}
+
+async function createMCPConfig(targetDir: string, force: boolean = false) {
+  // Determine the snow-flow installation directory
+  let snowFlowRoot: string;
+  
+  // Check if we're in a global npm installation
+  const isGlobalInstall = __dirname.includes('node_modules/snow-flow') || 
+                         __dirname.includes('node_modules/.pnpm') ||
+                         __dirname.includes('npm/snow-flow');
+  
+  if (isGlobalInstall) {
+    // For global installs, find the snow-flow package root
+    const parts = __dirname.split(/node_modules[\/\\]/);
+    snowFlowRoot = parts[0] + 'node_modules/snow-flow';
+  } else {
+    // For local development or local install
+    // Find the snow-flow project root by looking for the parent directory with package.json
+    let currentDir = __dirname;
+    while (currentDir !== '/') {
+      try {
+        const packageJsonPath = join(currentDir, 'package.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+        if (packageJson.name === 'snow-flow') {
+          snowFlowRoot = currentDir;
+          break;
+        }
+      } catch {
+        // Continue searching up
+      }
+      currentDir = dirname(currentDir);
+    }
+    if (!snowFlowRoot) {
+      throw new Error('Could not find snow-flow project root');
+    }
+  }
+  
+  // Read the template file
+  const templatePath = join(snowFlowRoot, '.mcp.json.template');
+  let templateContent: string;
+  
+  try {
+    templateContent = await fs.readFile(templatePath, 'utf-8');
+  } catch (error) {
+    console.error('❌ Could not find .mcp.json.template file');
+    throw error;
+  }
+  
+  // Replace placeholders in template
+  const distPath = join(snowFlowRoot, 'dist');
+  const mcpConfigContent = templateContent
+    .replace(/{{PROJECT_ROOT}}/g, snowFlowRoot)
+    .replace(/{{SNOW_INSTANCE}}/g, '${SNOW_INSTANCE}')
+    .replace(/{{SNOW_CLIENT_ID}}/g, '${SNOW_CLIENT_ID}')
+    .replace(/{{SNOW_CLIENT_SECRET}}/g, '${SNOW_CLIENT_SECRET}')
+    .replace(/{{SNOW_DEPLOYMENT_TIMEOUT}}/g, '${SNOW_DEPLOYMENT_TIMEOUT}')
+    .replace(/{{MCP_DEPLOYMENT_TIMEOUT}}/g, '${MCP_DEPLOYMENT_TIMEOUT}')
+    .replace(/{{NEO4J_URI}}/g, '${NEO4J_URI}')
+    .replace(/{{NEO4J_USER}}/g, '${NEO4J_USER}')
+    .replace(/{{NEO4J_PASSWORD}}/g, '${NEO4J_PASSWORD}')
+    .replace(/{{SNOW_FLOW_ENV}}/g, '${SNOW_FLOW_ENV}');
+  
+  // Parse to ensure it's valid JSON
+  const mcpConfig = JSON.parse(mcpConfigContent);
+  
+  // Update the structure to use mcpServers instead of servers
+  const finalConfig = {
+    "mcpServers": mcpConfig.servers
+  };
+  
+  // Create .mcp.json in project root for Claude Code discovery
+  const mcpConfigPath = join(targetDir, '.mcp.json');
+  try {
+    await fs.access(mcpConfigPath);
+    if (force) {
+      console.log('⚠️  .mcp.json already exists, overwriting with --force flag');
+      await fs.writeFile(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
+    } else {
+      console.log('⚠️  .mcp.json already exists, skipping (use --force to overwrite)');
+    }
+  } catch {
+    await fs.writeFile(mcpConfigPath, JSON.stringify(finalConfig, null, 2));
+  }
+  
+  // Also create legacy config in .claude for backward compatibility
+  const legacyConfigPath = join(targetDir, '.claude/mcp-config.json');
+  await fs.writeFile(legacyConfigPath, JSON.stringify(finalConfig, null, 2));
+  
+  // Create comprehensive Claude Code settings file
+  const claudeSettings = {
+    "enabledMcpjsonServers": [
+      "snow-flow",
+      "servicenow-deployment",
+      "servicenow-update-set",
+      "servicenow-intelligent",
+      "servicenow-memory",
+      "servicenow-operations",
+      "servicenow-platform-development",
+      "servicenow-integration",
+      "servicenow-automation",
+      "servicenow-security-compliance",
+      "servicenow-reporting-analytics"
+    ],
+    "permissions": {
+      "allow": [
+        "Bash(*)",
+        "Read(*)",
+        "Write(*)",
+        "Edit(*)",
+        "MultiEdit(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LS(*)",
+        "NotebookEdit(*)",
+        "NotebookRead(*)",
+        "WebFetch(*)",
+        "WebSearch(*)",
+        "TodoRead",
+        "TodoWrite",
+        "Task(*)",
+        "ListMcpResourcesTool",
+        "ReadMcpResourceTool",
+        "mcp__servicenow-*",
+        "mcp__snow-flow__*"
+      ],
+      "deny": []
+    },
+    "env": {
+      "BASH_DEFAULT_TIMEOUT_MS": "0",
+      "BASH_MAX_TIMEOUT_MS": "0",
+      "BASH_MAX_OUTPUT_LENGTH": "500000",
+      "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "true",
+      "MAX_THINKING_TOKENS": "50000",
+      "MCP_TIMEOUT": "0",
+      "MCP_TOOL_TIMEOUT": "0",
+      "DISABLE_COST_WARNINGS": "1",
+      "DISABLE_NON_ESSENTIAL_MODEL_CALLS": "0",
+      "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "32000",
+      "CLAUDE_CODE_TIMEOUT": "0",
+      "CLAUDE_CODE_SESSION_TIMEOUT": "0",
+      "CLAUDE_CODE_EXECUTION_TIMEOUT": "0"
+    },
+    "cleanupPeriodDays": 90,
+    "includeCoAuthoredBy": true,
+    "automation": {
+      "enabled": true,
+      "defaultTimeout": 300000,
+      "maxRetries": 3,
+      "retryBackoff": 2000,
+      "parallelExecution": true,
+      "batchOperations": true,
+      "autoSaveMemory": true,
+      "autoCommit": false
+    },
+    "snowFlow": {
+      "version": "1.4.35",
+      "swarmDefaults": {
+        "maxAgents": 10,
+        "timeout": 0,
+        "parallel": true,
+        "monitor": true,
+        "outputFormat": "json"
+      },
+      "sparcDefaults": {
+        "timeout": 0,
+        "parallel": true,
+        "batch": true,
+        "memoryKey": "sparc_session"
+      },
+      "memoryDefaults": {
+        "maxSize": "5GB",
+        "autoCompress": true,
+        "autoCleanup": true,
+        "indexingEnabled": true,
+        "persistenceEnabled": true
+      }
+    },
+    "mcpServers": {
+      "servicenow": {
+        "command": "node",
+        "args": ["dist/mcp/start-servicenow-mcp.js"],
+        "env": {
+          "SNOW_INSTANCE": "${SNOW_INSTANCE}",
+          "SNOW_CLIENT_ID": "${SNOW_CLIENT_ID}",
+          "SNOW_CLIENT_SECRET": "${SNOW_CLIENT_SECRET}"
+        }
+      }
+    }
+  };
+  
+  const claudeSettingsPath = join(targetDir, '.claude/settings.json');
+  await fs.writeFile(claudeSettingsPath, JSON.stringify(claudeSettings, null, 2));
+}
+
+// Direct widget creation command
+program
+  .command('create-widget [type]')
+  .description('Create a ServiceNow widget using templates')
+  .action(async (type: string = 'incident-management') => {
+    try {
+      // Use generic artifact deployment instead
+      console.log('🎯 Creating widget using template system...');
+      console.log('✨ Use: snow-flow deploy-artifact -t widget -c <config-file>');
+      console.log('📝 Or use: snow-flow swarm "create a widget for incident management"');
+    } catch (error) {
+      console.error('❌ Error creating widget:', error);
+    }
+  });
+
+// MCP Server command with subcommands
+program
+  .command('mcp <action>')
+  .description('Manage ServiceNow MCP servers for Claude Code integration')
+  .option('--server <name>', 'Specific server name to manage')
+  .option('--port <port>', 'Port for MCP server (default: auto)')
+  .option('--host <host>', 'Host for MCP server (default: localhost)')
+  .action(async (action: string, options) => {
+    const { MCPServerManager } = await import('./utils/mcp-server-manager.js');
+    const manager = new MCPServerManager();
+    
+    try {
+      await manager.initialize();
+      
+      switch (action) {
+        case 'start':
+          await handleMCPStart(manager, options);
+          break;
+        case 'stop':
+          await handleMCPStop(manager, options);
+          break;
+        case 'restart':
+          await handleMCPRestart(manager, options);
+          break;
+        case 'status':
+          await handleMCPStatus(manager, options);
+          break;
+        case 'logs':
+          await handleMCPLogs(manager, options);
+          break;
+        case 'list':
+          await handleMCPList(manager, options);
+          break;
+        case 'debug':
+          await handleMCPDebug(options);
+          break;
+        default:
+          console.error(`❌ Unknown action: ${action}`);
+          console.log('Available actions: start, stop, restart, status, logs, list, debug');
+          process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ MCP operation failed:', error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// MCP action handlers
+async function handleMCPStart(manager: any, options: any): Promise<void> {
+  console.log('🚀 Starting ServiceNow MCP Servers...');
+  
+  if (options.server) {
+    console.log(`📡 Starting server: ${options.server}`);
+    const success = await manager.startServer(options.server);
+    if (success) {
+      console.log(`✅ Server '${options.server}' started successfully`);
+    } else {
+      console.log(`❌ Failed to start server '${options.server}'`);
+      process.exit(1);
+    }
+  } else {
+    console.log('📡 Starting all configured MCP servers...');
+    await manager.startAllServers();
+    
+    const status = manager.getServerList();
+    const running = status.filter((s: any) => s.status === 'running').length;
+    const total = status.length;
+    
+    console.log(`\n✅ Started ${running}/${total} MCP servers`);
+    
+    if (running === total) {
+      console.log('🎉 All MCP servers are now running and available in Claude Code!');
+      console.log('\n📋 Next steps:');
+      console.log('   1. Open Claude Code');
+      console.log('   2. MCP tools will be automatically available');
+      console.log('   3. Use snow_deploy_widget, snow_deploy_flow, etc.');
+    } else {
+      console.log('⚠️  Some servers failed to start. Check logs with: snow-flow mcp logs');
+    }
+  }
+}
+
+async function handleMCPStop(manager: any, options: any): Promise<void> {
+  if (options.server) {
+    console.log(`🛑 Stopping server: ${options.server}`);
+    const success = await manager.stopServer(options.server);
+    if (success) {
+      console.log(`✅ Server '${options.server}' stopped successfully`);
+    } else {
+      console.log(`❌ Failed to stop server '${options.server}'`);
+      process.exit(1);
+    }
+  } else {
+    console.log('🛑 Stopping all MCP servers...');
+    await manager.stopAllServers();
+    console.log('✅ All MCP servers stopped');
+  }
+}
+
+async function handleMCPRestart(manager: any, options: any): Promise<void> {
+  if (options.server) {
+    console.log(`🔄 Restarting server: ${options.server}`);
+    await manager.stopServer(options.server);
+    const success = await manager.startServer(options.server);
+    if (success) {
+      console.log(`✅ Server '${options.server}' restarted successfully`);
+    } else {
+      console.log(`❌ Failed to restart server '${options.server}'`);
+      process.exit(1);
+    }
+  } else {
+    console.log('🔄 Restarting all MCP servers...');
+    await manager.stopAllServers();
+    await manager.startAllServers();
+    
+    const running = manager.getRunningServersCount();
+    const total = manager.getServerList().length;
+    console.log(`✅ Restarted ${running}/${total} MCP servers`);
+  }
+}
+
+async function handleMCPStatus(manager: any, options: any): Promise<void> {
+  const servers = manager.getServerList();
+  
+  console.log('\n📊 MCP Server Status');
+  console.log('═'.repeat(80));
+  
+  if (servers.length === 0) {
+    console.log('No MCP servers configured');
+    return;
+  }
+  
+  servers.forEach((server: any) => {
+    const statusIcon = server.status === 'running' ? '✅' : 
+                      server.status === 'starting' ? '🔄' : 
+                      server.status === 'error' ? '❌' : '⭕';
+    
+    console.log(`${statusIcon} ${server.name}`);
+    console.log(`   Status: ${server.status}`);
+    console.log(`   Script: ${server.script}`);
+    
+    if (server.pid) {
+      console.log(`   PID: ${server.pid}`);
+    }
+    
+    if (server.startedAt) {
+      console.log(`   Started: ${server.startedAt.toLocaleString()}`);
+    }
+    
+    if (server.lastError) {
+      console.log(`   Last Error: ${server.lastError}`);
+    }
+    
+    console.log('');
+  });
+  
+  const running = servers.filter((s: any) => s.status === 'running').length;
+  const total = servers.length;
+  
+  console.log(`📈 Summary: ${running}/${total} servers running`);
+  
+  if (running === total) {
+    console.log('🎉 All MCP servers are operational and available in Claude Code!');
+  } else if (running > 0) {
+    console.log('⚠️  Some servers are not running. Use "snow-flow mcp start" to start them.');
+  } else {
+    console.log('💡 No servers running. Use "snow-flow mcp start" to start all servers.');
+  }
+}
+
+async function handleMCPLogs(manager: any, options: any): Promise<void> {
+  const { join } = require('path');
+  const { promises: fs } = require('fs');
+  
+  const logDir = join(process.env.SNOW_FLOW_HOME || join(os.homedir(), '.snow-flow'), 'logs');
+  
+  try {
+    const logFiles = await fs.readdir(logDir);
+    
+    if (options.server) {
+      const serverLogFile = `${options.server.replace(/\\s+/g, '_').toLowerCase()}.log`;
+      if (logFiles.includes(serverLogFile)) {
+        console.log(`📄 Logs for ${options.server}:`);
+        console.log('═'.repeat(80));
+        const logContent = await fs.readFile(join(logDir, serverLogFile), 'utf-8');
+        console.log(logContent);
+      } else {
+        console.log(`❌ No logs found for server '${options.server}'`);
+      }
+    } else {
+      console.log('📄 Available log files:');
+      logFiles.forEach((file: string) => {
+        console.log(`   - ${file}`);
+      });
+      console.log('\\n💡 Use --server <name> to view specific server logs');
+    }
+  } catch (error) {
+    console.log('📄 No log files found');
+  }
+}
+
+async function handleMCPList(manager: any, options: any): Promise<void> {
+  const servers = manager.getServerList();
+  
+  console.log('\n📋 Configured MCP Servers');
+  console.log('═'.repeat(80));
+  
+  if (servers.length === 0) {
+    console.log('No MCP servers configured');
+    console.log('💡 Run "snow-flow init" to configure default MCP servers');
+    return;
+  }
+  
+  servers.forEach((server: any, index: number) => {
+    console.log(`${index + 1}. ${server.name}`);
+    console.log(`   Script: ${server.script}`);
+    console.log(`   Status: ${server.status}`);
+    console.log('');
+  });
+}
+
+async function handleMCPDebug(options: any): Promise<void> {
+  console.log('🔍 MCP Debug Information');
+  console.log('========================\n');
+  
+  const { existsSync, readFileSync } = require('fs');
+  const { join, resolve } = require('path');
+  
+  // Check .mcp.json
+  const mcpJsonPath = join(process.cwd(), '.mcp.json');
+  console.log('📄 .mcp.json:');
+  if (existsSync(mcpJsonPath)) {
+    console.log(`   ✅ Found at: ${mcpJsonPath}`);
+    try {
+      const mcpConfig = JSON.parse(readFileSync(mcpJsonPath, 'utf8'));
+      console.log(`   📊 Servers configured: ${Object.keys(mcpConfig.servers || {}).length}`);
+      
+      // Check if paths exist
+      for (const [name, config] of Object.entries(mcpConfig.servers || {})) {
+        const serverConfig = config as any;
+        if (serverConfig.args && serverConfig.args[0]) {
+          const scriptPath = serverConfig.args[0];
+          const exists = existsSync(scriptPath);
+          console.log(`   ${exists ? '✅' : '❌'} ${name}: ${scriptPath}`);
+        }
+      }
+    } catch (error) {
+      console.log(`   ❌ Error reading: ${error}`);
+    }
+  } else {
+    console.log(`   ❌ Not found at: ${mcpJsonPath}`);
+  }
+  
+  // Check .claude/settings.json
+  console.log('\n📄 .claude/settings.json:');
+  const claudeSettingsPath = join(process.cwd(), '.claude/settings.json');
+  if (existsSync(claudeSettingsPath)) {
+    console.log(`   ✅ Found at: ${claudeSettingsPath}`);
+    try {
+      const settings = JSON.parse(readFileSync(claudeSettingsPath, 'utf8'));
+      const enabledServers = settings.enabledMcpjsonServers || [];
+      console.log(`   📊 Enabled servers: ${enabledServers.length}`);
+      enabledServers.forEach((server: string) => {
+        console.log(`      - ${server}`);
+      });
+    } catch (error) {
+      console.log(`   ❌ Error reading: ${error}`);
+    }
+  } else {
+    console.log(`   ❌ Not found at: ${claudeSettingsPath}`);
+  }
+  
+  // Check environment
+  console.log('\n🔐 Environment:');
+  console.log(`   SNOW_INSTANCE: ${process.env.SNOW_INSTANCE ? '✅ Set' : '❌ Not set'}`);
+  console.log(`   SNOW_CLIENT_ID: ${process.env.SNOW_CLIENT_ID ? '✅ Set' : '❌ Not set'}`);
+  console.log(`   SNOW_CLIENT_SECRET: ${process.env.SNOW_CLIENT_SECRET ? '✅ Set' : '❌ Not set'}`);
+  
+  // Check Claude Code
+  console.log('\n🤖 Claude Code:');
+  const { execSync } = require('child_process');
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    console.log('   ✅ Claude Code CLI found');
+  } catch {
+    console.log('   ❌ Claude Code CLI not found in PATH');
+  }
+  
+  console.log('\n💡 Tips:');
+  console.log('   1. Make sure Claude Code is started in this directory');
+  console.log('   2. Check if MCP servers appear with /mcp command in Claude Code');
+  console.log('   3. Approve MCP servers when prompted by Claude Code');
+  console.log('   4. Ensure .env file has valid ServiceNow credentials');
+}
+
+
+// SPARC Detailed Help Command
+program
+  .command('sparc-help')
+  .description('Show detailed SPARC help information')
+  .action(async () => {
+    try {
+      const { displayTeamHelp } = await import('./sparc/sparc-help.js');
+      displayTeamHelp();
+    } catch (error) {
+      console.error('❌ Failed to load SPARC help:', error instanceof Error ? error.message : String(error));
+    }
+  });
+
+// ===================================================
+// 👑 QUEEN AGENT COMMANDS - Elegant Orchestration
+// ===================================================
+
+/**
+ * Main Queen command - replaces complex swarm orchestration
+ * Simple, elegant, and intelligent ServiceNow objective execution
+ */
+program
+  .command('queen <objective>')
+  .description('🐝 Execute ServiceNow objective with Queen Agent hive-mind intelligence')
+  .option('--learn', 'Enable enhanced learning from execution (default: true)', true)
+  .option('--no-learn', 'Disable learning')
+  .option('--debug', 'Enable debug mode for detailed insights')
+  .option('--dry-run', 'Preview execution plan without deployment')
+  .option('--memory-driven', 'Use memory for optimal workflow patterns')
+  .option('--monitor', 'Show real-time hive-mind monitoring')
+  .option('--type <type>', 'Hint at task type (widget, flow, app, integration)')
+  .action(async (objective: string, options) => {
+    // Check for flow deprecation first
+    checkFlowDeprecation('queen', objective);
+    
+    console.log(`\n👑 ServiceNow Queen Agent v${VERSION} - Hive-Mind Intelligence`);
+    console.log('🐝 Elegant orchestration replacing complex team coordination\n');
+    
+    try {
+      const { QueenIntegration } = await import('./examples/queen/integration-example.js');
+      
+      const queenIntegration = new QueenIntegration({
+        debugMode: options.debug || false
+      });
+
+      if (options.dryRun) {
+        console.log('🔍 DRY RUN MODE - Analyzing objective...');
+        // TODO: Add dry run analysis
+        console.log(`📋 Objective: ${objective}`);
+        console.log('🎯 Queen would analyze, spawn agents, coordinate, and deploy');
+        return;
+      }
+
+      console.log(`🎯 Queen analyzing objective: ${objective}`);
+      
+      const result = await queenIntegration.executeSwarmObjective(objective, {
+        learn: options.learn,
+        memoryDriven: options.memoryDriven,
+        monitor: options.monitor
+      });
+
+      if (result.success) {
+        console.log('\n✅ Queen Agent completed objective successfully!');
+        console.log(`🐝 Hive-Mind coordination: ${result.queen_managed ? 'ACTIVE' : 'INACTIVE'}`);
+        
+        if (result.hive_mind_status) {
+          console.log(`👥 Active Agents: ${result.hive_mind_status.activeAgents}`);
+          console.log(`📋 Active Tasks: ${result.hive_mind_status.activeTasks}`);
+          console.log(`🧠 Learned Patterns: ${result.hive_mind_status.memoryStats.patterns}`);
+        }
+
+        if (options.monitor) {
+          console.log('\n📊 HIVE-MIND MONITORING:');
+          queenIntegration.logHiveMindStatus();
+        }
+      } else {
+        console.error('\n❌ Queen Agent execution failed!');
+        if (result.fallback_required) {
+          console.log('🔄 Consider using traditional swarm command as fallback:');
+          console.log(`   snow-flow swarm "${objective}"`);
+        }
+        process.exit(1);
+      }
+
+      await queenIntegration.shutdown();
+
+    } catch (error) {
+      console.error('\n💥 Queen Agent error:', (error as Error).message);
+      console.log('\n🔄 Fallback to traditional swarm:');
+      console.log(`   snow-flow swarm "${objective}"`);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Queen Memory Management
+ */
+const queenMemory = program.command('queen-memory');
+queenMemory.description('🧠 Manage Queen Agent hive-mind memory');
+
+queenMemory
+  .command('export [file]')
+  .description('Export Queen memory to file')
+  .action(async (file: string = 'queen-memory.json') => {
+    console.log(`\n🧠 Exporting Queen hive-mind memory to ${file}...`);
+    
+    try {
+      const { createServiceNowQueen } = await import('./queen/index.js');
+      const queen = createServiceNowQueen({ debugMode: true });
+      
+      const memoryData = queen.exportMemory();
+      
+      const { promises: fs } = await import('fs');
+      await fs.writeFile(file, memoryData, 'utf-8');
+      
+      console.log(`✅ Memory exported successfully to ${file}`);
+      console.log(`📊 Memory contains learned patterns and successful deployments`);
+      
+      await queen.shutdown();
+    } catch (error) {
+      console.error('❌ Memory export failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+queenMemory
+  .command('import <file>')
+  .description('Import Queen memory from file')
+  .action(async (file: string) => {
+    console.log(`\n🧠 Importing Queen hive-mind memory from ${file}...`);
+    
+    try {
+      const { promises: fs } = await import('fs');
+      const memoryData = await fs.readFile(file, 'utf-8');
+      
+      const { createServiceNowQueen } = await import('./queen/index.js');
+      const queen = createServiceNowQueen({ debugMode: true });
+      
+      queen.importMemory(memoryData);
+      
+      console.log(`✅ Memory imported successfully from ${file}`);
+      console.log(`🧠 Queen now has access to previous learning patterns`);
+      
+      await queen.shutdown();
+    } catch (error) {
+      console.error('❌ Memory import failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+queenMemory
+  .command('clear')
+  .description('Clear Queen memory (reset learning)')
+  .option('--confirm', 'Confirm memory clearing')
+  .action(async (options) => {
+    if (!options.confirm) {
+      console.log('\n⚠️  This will clear all Queen hive-mind learning!');
+      console.log('Use --confirm to proceed: snow-flow queen-memory clear --confirm');
+      return;
+    }
+
+    console.log('\n🧠 Clearing Queen hive-mind memory...');
+    
+    try {
+      const { createServiceNowQueen } = await import('./queen/index.js');
+      const queen = createServiceNowQueen({ debugMode: true });
+      
+      queen.clearMemory();
+      
+      console.log('✅ Queen memory cleared successfully');
+      console.log('🔄 Queen will start fresh learning from next execution');
+      
+      await queen.shutdown();
+    } catch (error) {
+      console.error('❌ Memory clear failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Queen Status and Insights
+ */
+program
+  .command('queen-status')
+  .description('📊 Show Queen Agent hive-mind status and insights')
+  .option('--detailed', 'Show detailed memory and learning statistics')
+  .action(async (options) => {
+    console.log(`\n👑 ServiceNow Queen Agent Status v${VERSION}`);
+    
+    try {
+      const { createServiceNowQueen } = await import('./queen/index.js');
+      const queen = createServiceNowQueen({ debugMode: true });
+      
+      const status = queen.getHiveMindStatus();
+      
+      console.log('\n🐝 HIVE-MIND STATUS 🐝');
+      console.log('═══════════════════════');
+      console.log(`📋 Active Tasks: ${status.activeTasks}`);
+      console.log(`👥 Active Agents: ${status.activeAgents}`);
+      console.log(`🧠 Learned Patterns: ${status.memoryStats.patterns}`);
+      console.log(`📚 Stored Artifacts: ${status.memoryStats.artifacts}`);
+      console.log(`💡 Learning Insights: ${status.memoryStats.learnings}`);
+      
+      if (status.factoryStats.agentTypeCounts) {
+        console.log('\n👥 AGENT BREAKDOWN:');
+        Object.entries(status.factoryStats.agentTypeCounts).forEach(([type, count]) => {
+          console.log(`   ${type}: ${count}`);
+        });
+      }
+
+      if (options.detailed) {
+        console.log('\n🔍 DETAILED MEMORY ANALYSIS:');
+        console.log(`   Memory Size: ${status.memoryStats.totalSize || 'Unknown'}`);
+        console.log(`   Success Rate: ${status.memoryStats.successRate || 'Unknown'}%`);
+        console.log(`   Most Effective Pattern: ${status.memoryStats.bestPattern || 'Learning...'}`);
+      }
+      
+      console.log('═══════════════════════\n');
+      
+      await queen.shutdown();
+    } catch (error) {
+      console.error('❌ Status check failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('queen-insights')
+  .description('💡 Show Queen Agent learning insights and recommendations')
+  .action(async () => {
+    console.log(`\n💡 Queen Agent Learning Insights v${VERSION}`);
+    
+    try {
+      const { createServiceNowQueen } = await import('./queen/index.js');
+      const queen = createServiceNowQueen({ debugMode: true });
+      
+      const insights = queen.getLearningInsights();
+      
+      console.log('\n🧠 LEARNING INSIGHTS 🧠');
+      console.log('═══════════════════════');
+      
+      if (insights.successfulPatterns && insights.successfulPatterns.length > 0) {
+        console.log('\n✅ SUCCESSFUL PATTERNS:');
+        insights.successfulPatterns.forEach((pattern, idx) => {
+          console.log(`   ${idx + 1}. ${pattern.description} (${pattern.successRate}% success)`);
+        });
+      } else {
+        console.log('\n📚 No patterns learned yet - execute objectives to build intelligence');
+      }
+      
+      if (insights.recommendations && insights.recommendations.length > 0) {
+        console.log('\n💡 RECOMMENDATIONS:');
+        insights.recommendations.forEach((rec, idx) => {
+          console.log(`   ${idx + 1}. ${rec}`);
+        });
+      }
+      
+      if (insights.commonTasks && insights.commonTasks.length > 0) {
+        console.log('\n🎯 COMMON TASK TYPES:');
+        insights.commonTasks.forEach((task, idx) => {
+          console.log(`   ${idx + 1}. ${task.type}: ${task.count} executions`);
+        });
+      }
+      
+      console.log('═══════════════════════\n');
+      
+      await queen.shutdown();
+    } catch (error) {
+      console.error('❌ Insights failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// ===================================================
+// 🔄 BACKWARD COMPATIBILITY ENHANCEMENTS
+// ===================================================
+
+/**
+ * Enhance existing swarm command with optional Queen intelligence
+ * 
+ * Note: Users can use: snow-flow swarm "objective" --queen
+ * This will be implemented in a future version once the Queen system is stable.
+ */
+
+// ===================================================
+// 🎯 INTEGRATE SNOW-FLOW HIVE-MIND SYSTEM
+// ===================================================
+
+
+// Note: The new integrated commands enhance the existing CLI with:
+// - Advanced system status monitoring
+// - Real-time monitoring dashboard
+// - Persistent memory management
+// - Configuration management
+// - Performance analytics
+// Comment out the line below to disable the integrated commands
+// CLI integration removed - swarm command is implemented directly above
+
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}