snow-flow 3.3.2 → 3.3.4

package/dist/cli.js

@@ -608,28 +608,12 @@ async function executeWithClaude(claudeCommand, prompt, resolve) {
     });
 }
 // Helper function to build Queen Agent orchestration prompt
+// Helper function to build Queen Agent orchestration prompt - CLEANED UP VERSION
 function buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated = false, sessionId, isFlowDesignerTask = false) {
     // 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
@@ -664,13 +648,12 @@ You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mis
 
 **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!
+${isFlowDesignerTask ? `## 🔧 Flow Designer Task Detected - Using Enhanced Flow Creation!
 
 **MANDATORY: Use this exact approach for Flow Designer tasks:**
 
 \`\`\`javascript
-// ✅ ENHANCED v2.0: Complete flow generation with ALL features
+// ✅ Complete flow generation with ALL features
 await snow_create_flow({
   instruction: "your natural language flow description", 
   deploy_immediately: true,  // 🔥 Automatically deploys to ServiceNow!
@@ -678,32 +661,14 @@ await snow_create_flow({
 });
 \`\`\`
 
-🎯 **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!
+🎯 **What this does automatically:**
+- ✅ Generates proper flow structure with all components
+- ✅ Uses correct ServiceNow tables and relationships
+- ✅ Deploys directly to your ServiceNow instance
+- ✅ Returns complete metadata (sys_id, URLs, endpoints)
+- ✅ Includes all requested features and logic
 
 ` : ''}
-- **Recommended Team**: ${getTeamRecommendation(taskAnalysis.taskType)}
 
 ## 📊 Table Discovery Intelligence
 
@@ -745,165 +710,53 @@ for (let i = 0; i < 5000; i += 100) {
 }
 \`\`\`
 
-### 1. CRITICAL: Initialize Memory FIRST (Before Everything!)
-**THIS MUST BE YOUR VERY FIRST ACTION - Initialize the swarm memory session:**
+### 1. Initialize Memory & Session (Required First Step)
+**THIS MUST BE YOUR VERY FIRST ACTION:**
 \`\`\`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
+// Initialize swarm memory session
+Memory.store("swarm_session_${sessionId}", JSON.stringify({
+  objective: "${objective}",
+  status: "initializing",
+  started_at: new Date().toISOString(),
+  task_analysis: ${JSON.stringify(taskAnalysis, null, 2)},
+  configuration: {
+    strategy: "${options.strategy}",
+    mode: "${options.mode}",
+    max_agents: ${parseInt(options.maxAgents)},
+    authenticated: ${isAuthenticated}
+  }
+}));
 \`\`\`
 
-### 2. MANDATORY MCP-FIRST Workflow Steps
-**Execute these steps IN ORDER before spawning agents:**
+### 2. Validate ServiceNow Connection
+**Execute these steps IN ORDER:**
 
 \`\`\`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") {
+// Step 2.1: Test ServiceNow authentication
+const authCheck = await snow_auth_diagnostics();
+if (!authCheck.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
+// Step 2.2: Create Update Set for tracking changes
 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({
+const updateSet = await 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}"
-});
+Memory.store("update_set_${sessionId}", JSON.stringify(updateSet));
 \`\`\`
 
 ### 3. Create Master Task List
-After completing MCP-FIRST steps, create task breakdown:
+After completing setup steps, create task breakdown:
 \`\`\`javascript
 TodoWrite([
   {
-    id: "mcp_workflow_complete",
-    content: "✅ MCP-FIRST workflow: Auth, Discovery, Update Set, Tables",
+    id: "setup_complete",
+    content: "✅ Setup: Auth, Update Set, Memory initialized",
     status: "completed",
     priority: "high"
   },
@@ -934,39 +787,38 @@ TodoWrite([
 ]);
 \`\`\`
 
-### 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.
+### 4. Agent Spawning Strategy
+Based on the task analysis, spawn ${taskAnalysis.estimatedAgentCount} agents in smart batches:
 
-${getAgentSpawnStrategy(taskAnalysis)}
+**Agent Spawn Order:**
+1. **Primary Agent**: Spawn ${taskAnalysis.primaryAgent} first
+2. **Supporting Agents**: Spawn ${taskAnalysis.supportingAgents.join(', ')} after primary is established
+3. **Use Task tool**: \`Task("agent description", "agent prompt")\` for each agent
 
 ### 5. Memory Coordination Pattern
-All agents MUST use this memory coordination pattern:
+All agents MUST use this simple memory coordination:
 
 \`\`\`javascript
 // Agent initialization
-const session = Memory.get("swarm_session_${sessionId}");
 const agentId = \`agent_\${agentType}_${sessionId}\`;
 
 // Agent stores progress
-Memory.store(\`\${agentId}_progress\`, {
+Memory.store(\`\${agentId}_progress\`, JSON.stringify({
   status: "working",
   current_task: "description of current work",
   completion_percentage: 45,
   last_update: new Date().toISOString()
-});
+}));
 
-// Agent reads other agent's work
+// Agent reads other agent's work when needed
 const primaryWork = Memory.get("agent_${taskAnalysis.primaryAgent}_output");
 
 // Agent signals completion
-Memory.store(\`\${agentId}_complete\`, {
+Memory.store(\`\${agentId}_complete\`, JSON.stringify({
   completed_at: new Date().toISOString(),
   outputs: { /* agent deliverables */ },
   artifacts_created: [ /* list of created artifacts */ ]
-});
+}));
 \`\`\`
 
 ## 🧠 Intelligent Features Configuration
@@ -986,386 +838,75 @@ ${hasIntelligentFeatures ? `✅ **INTELLIGENT MODE ACTIVE** - The following feat
 
 **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!)
+#### Current MCP Tools Available (Snow-Flow v3.3.4)
 ${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
+1. \`snow_auth_diagnostics\` - Test authentication and permissions
 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
-});
-\`\`\`
+🎯 **Core Development Tools**:
+1. **Universal Query Tool**: \`snow_query_table\` - Works with ALL ServiceNow tables
+   - Count-only: \`{table: "incident", query: "state!=7"}\` → Memory efficient
+   - Specific fields: \`{table: "sc_request", fields: ["number", "state"]}\` → Only needed data
+   - Full content: \`{table: "change_request", include_content: true}\` → When all data needed
 
-**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
-});
-\`\`\`
+2. **Deployment Tools**: 
+   - \`snow_deploy\` - Universal deployment for NEW artifacts (16+ types supported!)
+   - \`snow_update\` - Update EXISTING artifacts by name or sys_id
 
-**Process Mining:**
-\`\`\`javascript
-// Discover real incident management processes
-await snow_discover_process({
-  process_type: "incident_management",
-  analysis_period: "30d",
-  include_variants: true
-});
+3. **Discovery Tools**:
+   - \`snow_discover_table_fields\` - Get exact field names and types
+   - \`snow_table_schema_discovery\` - Complete table structure
 
-// Monitor processes in real-time
-await snow_monitor_process({
-  process_name: "incident_resolution",
-  tables_to_monitor: ["incident", "task"],
-  monitoring_duration: "24h"
-});
-\`\`\`
-
-**Intelligence & Automation:**
+4. **Update Set Management**:
+   - \`snow_update_set_create\` - Create new update sets
+   - \`snow_update_set_add_comment\` - Track progress
+   - \`snow_update_set_retrieve\` - Get update set XML
+
+## 🔧 NEW: Expanded Artifact Support (v3.3.4)
+
+Snow-Flow now supports **16+ different ServiceNow artifact types**:
+
+| Type | Table | Deploy | Update | Natural Language |
+|------|-------|--------|---------|------------------|
+| widget | sp_widget | ✅ | ✅ | ✅ |
+| business_rule | sys_script | ✅ | ✅ | ✅ |
+| script_include | sys_script_include | ✅ | ✅ | ✅ |
+| ui_page | sys_ui_page | ✅ | ✅ | ✅ |
+| client_script | sys_script_client | ✅ | ✅ | ✅ |
+| ui_action | sys_ui_action | ✅ | ✅ | ✅ |
+| ui_policy | sys_ui_policy | ✅ | ✅ | ✅ |
+| acl | sys_security_acl | ✅ | ✅ | ✅ |
+| table | sys_db_object | ✅ | ✅ | ✅ |
+| field | sys_dictionary | ✅ | ✅ | ✅ |
+| workflow | wf_workflow | ✅ | ✅ | ✅ |
+| flow | sys_hub_flow | ✅ | ✅ | ✅ |
+| notification | sysevent_email_action | ✅ | ✅ | ✅ |
+| scheduled_job | sysauto_script | ✅ | ✅ | ✅ |
+
+**Usage Examples:**
 \`\`\`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
+// Deploy NEW artifacts
+await snow_deploy({
+  type: 'business_rule',
+  name: 'Auto Assignment Rule',
+  table: 'incident',
+  when: 'before',
+  script: 'if (current.priority == "1") current.assigned_to = "admin";'
 });
 
-// Auto-generate documentation
-await snow_generate_documentation({
-  documentation_scope: ["tables", "workflows"],
-  output_format: "markdown",
-  include_diagrams: true
+// Update EXISTING artifacts (natural language supported!)
+await snow_update({
+  type: 'ui_action',
+  identifier: 'close_incident',
+  instruction: 'Change label to "Close with Resolution" and add validation'
 });
 \`\`\`
 
-🚨 **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
@@ -1377,6 +918,7 @@ ${options.autoDeploy ? `
 - Analysis and recommendations only
 - Use --auto-deploy to enable deployment
 `}
+
 ${!isAuthenticated ? `### ❌ ServiceNow Integration Disabled
 
 #### Planning Mode (Auth Required)
@@ -1391,109 +933,19 @@ 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
+### 6. Agent Coordination & Handoffs
 Ensure smooth transitions between agents:
 
 \`\`\`javascript
 // Primary agent signals readiness for support
-Memory.store("agent_${taskAnalysis.primaryAgent}_ready_for_support", {
+Memory.store("agent_${taskAnalysis.primaryAgent}_ready_for_support", JSON.stringify({
   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");
+const canProceed = JSON.parse(Memory.get("agent_${taskAnalysis.primaryAgent}_ready_for_support") || "{}");
 if (canProceed?.base_structure_complete) {
   // Begin supporting work
 }
@@ -1508,19 +960,19 @@ const agentOutputs = {};
 [${[taskAnalysis.primaryAgent, ...taskAnalysis.supportingAgents].map(a => `"${a}"`).join(', ')}].forEach(agent => {
   const output = Memory.get(\`agent_\${agent}_complete\`);
   if (output) {
-    agentOutputs[agent] = output;
+    agentOutputs[agent] = JSON.parse(output);
   }
 });
 
 // Store final swarm results
-Memory.store("swarm_session_${sessionId}_results", {
+Memory.store("swarm_session_${sessionId}_results", JSON.stringify({
   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([
@@ -1533,26 +985,6 @@ TodoWrite([
 ]);
 \`\`\`
 
-## 📊 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:
@@ -1560,107 +992,18 @@ Your Queen Agent orchestration is successful when:
 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
+5. ✅ ${taskAnalysis.taskType} requirements are met
+6. ✅ 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
+2. **Use Memory with JSON.stringify/parse** 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:
@@ -1672,127 +1015,16 @@ Now execute this Queen Agent orchestration plan:
 
 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
-});
+## 📊 Session Information
+- **Session ID**: ${sessionId}
+- **Snow-Flow Version**: v3.3.4
+- **Authentication**: ${isAuthenticated ? 'Active' : 'Required'}
+- **Deployment Mode**: ${options.autoDeploy ? 'Live deployment enabled' : 'Planning mode'}
+- **Estimated Agents**: ${taskAnalysis.estimatedAgentCount}
+- **Primary Agent**: ${taskAnalysis.primaryAgent}
 
-// 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}`;
+🎯 **Ready to begin orchestration!**
+`;
     return prompt;
 }
 function getTeamRecommendation(taskType) {