snow-flow 2.0.2 → 2.0.3

package/src/mcp/servicenow-intelligent-mcp.ts

@@ -1,4638 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow Intelligent MCP Server
- * Natural language processing for ServiceNow artifacts with intelligent indexing
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListToolsRequestSchema,
-  McpError,
-} from '@modelcontextprotocol/sdk/types.js';
-import { ServiceNowClient } from '../utils/servicenow-client.js';
-import { mcpAuth } from '../utils/mcp-auth-middleware.js';
-import { mcpConfig } from '../utils/mcp-config-manager.js';
-import { Logger } from '../utils/logger.js';
-import { widgetTemplateGenerator } from '../utils/widget-template-generator.js';
-import { promises as fs } from 'fs';
-import { join } from 'path';
-import { SelfDocumentingSystem } from '../documentation/self-documenting-system.js';
-import { CostOptimizationEngine } from '../optimization/cost-optimization-engine.js';
-import { AdvancedComplianceSystem } from '../compliance/advanced-compliance-system.js';
-import { SelfHealingSystem } from '../healing/self-healing-system.js';
-import { MemorySystem } from '../memory/memory-system.js';
-
-interface ParsedIntent {
-  action: 'find' | 'edit' | 'create' | 'clone';
-  artifactType: string; // Allow any artifact type from the comprehensive table mapping
-  identifier: string;
-  modification?: string;
-  confidence: number;
-}
-
-interface IndexedArtifact {
-  meta: {
-    sys_id: string;
-    name: string;
-    title?: string;
-    type: string;
-    last_updated: string;
-  };
-  structure: any;
-  context: any;
-  relationships: any;
-  claudeSummary: string;
-  modificationPoints: any[];
-}
-
-export class ServiceNowIntelligentMCP {
-  private server: Server;
-  private client: ServiceNowClient;
-  private logger: Logger;
-  private memoryPath: string;
-  private config: ReturnType<typeof mcpConfig.getMemoryConfig>;
-  private documentationSystem: SelfDocumentingSystem;
-  private costOptimizationEngine: CostOptimizationEngine;
-  private complianceSystem: AdvancedComplianceSystem;
-  private selfHealingSystem: SelfHealingSystem;
-  private memorySystem: MemorySystem;
-  private memoryIndex: Map<string, any> = new Map();
-
-  constructor() {
-    this.server = new Server(
-      {
-        name: 'servicenow-intelligent',
-        version: '1.0.0',
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      }
-    );
-
-    this.client = new ServiceNowClient();
-    this.logger = new Logger('ServiceNowIntelligentMCP');
-    this.config = mcpConfig.getMemoryConfig();
-    this.memoryPath = this.config.path || join(process.cwd(), 'memory', 'servicenow_artifacts');
-    
-    this.setupHandlers();
-  }
-
-  private async initializeSystems(): Promise<void> {
-    try {
-      // Initialize systems synchronously during server startup
-      this.memorySystem = new MemorySystem({
-        dbPath: './intelligent-mcp.db',
-        cache: { enabled: true, maxSize: 100, ttl: 3600 },
-        ttl: { default: 3600, session: 7200, artifact: 86400, metric: 604800 }
-      });
-      
-      await this.memorySystem.initialize();
-      this.logger.info('Memory system initialized');
-      
-      this.documentationSystem = new SelfDocumentingSystem(this.client, this.memorySystem);
-      this.costOptimizationEngine = new CostOptimizationEngine(this.client, this.memorySystem);
-      this.complianceSystem = new AdvancedComplianceSystem(this.client, this.memorySystem);
-      this.selfHealingSystem = new SelfHealingSystem(this.client, this.memorySystem);
-      
-      this.logger.info('All systems initialized successfully');
-    } catch (error) {
-      this.logger.error('Failed to initialize systems:', error);
-      // Initialize minimal fallback systems
-      this.memorySystem = new MemorySystem({ dbPath: './intelligent-mcp.db' });
-      await this.memorySystem.initialize();
-    }
-  }
-
-  private setupHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        {
-          name: 'snow_find_artifact',
-          description: 'AUTONOMOUS artifact discovery - finds ServiceNow artifacts using natural language, searches memory first, then ServiceNow. NO MANUAL SEARCH NEEDED.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              query: { type: 'string', description: 'Natural language query (e.g., "the widget that shows incidents on homepage")' },
-              type: { type: 'string', enum: ['widget', 'flow', 'script', 'application', 'any'], description: 'Artifact type filter' },
-            },
-            required: ['query'],
-          },
-        },
-        {
-          name: 'snow_edit_artifact',
-          description: 'AUTONOMOUS artifact modification - edits ServiceNow artifacts using natural language, handles errors automatically, retries on failure. DIRECT MODIFICATION.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              query: { type: 'string', description: 'Natural language edit instruction (e.g., "pas de flow aan met de naam approval request flow en zorg dat er na de approval stap een mailtje naar test@admin.nl wordt gestuurd")' },
-            },
-            required: ['query'],
-          },
-        },
-        {
-          name: 'snow_get_by_sysid',
-          description: 'DIRECT sys_id lookup - get artifact by exact sys_id, much faster and more reliable than text search',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sys_id: { type: 'string', description: 'System ID of the artifact' },
-              table: { type: 'string', description: 'ServiceNow table name (e.g., sp_widget, wf_workflow, sys_script_include)' },
-            },
-            required: ['sys_id', 'table'],
-          },
-        },
-        {
-          name: 'snow_edit_by_sysid',
-          description: 'DIRECT sys_id edit - update specific fields of artifact by sys_id, much more reliable than text-based search',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sys_id: { type: 'string', description: 'System ID of the artifact to edit' },
-              table: { type: 'string', description: 'ServiceNow table name' },
-              field: { type: 'string', description: 'Field name to update (e.g., script, server_script, template)' },
-              value: { type: 'string', description: 'New value for the field' },
-            },
-            required: ['sys_id', 'table', 'field', 'value'],
-          },
-        },
-        {
-          name: 'snow_analyze_artifact',
-          description: 'AUTONOMOUS deep _analysis - intelligently indexes artifacts for optimal Claude understanding, stores in memory for future use. SELF-LEARNING SYSTEM.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sys_id: { type: 'string', description: 'System ID of the artifact' },
-              table: { type: 'string', description: 'ServiceNow table name' },
-            },
-            required: ['sys_id', 'table'],
-          },
-        },
-        {
-          name: 'snow_memory_search',
-          description: 'Search indexed ServiceNow artifacts in memory',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              query: { type: 'string', description: 'Search query' },
-              type: { type: 'string', enum: ['widget', 'flow', 'script', 'application'], description: 'Artifact type' },
-            },
-            required: ['query'],
-          },
-        },
-        {
-          name: 'snow_comprehensive_search',
-          description: 'COMPREHENSIVE multi-table search - searches across all relevant ServiceNow tables for artifacts. Perfect for finding hard-to-locate items.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              query: { type: 'string', description: 'Natural language search query' },
-              include_inactive: { type: 'boolean', description: 'Include inactive records', default: false },
-            },
-            required: ['query'],
-          },
-        },
-        {
-          name: 'snow_sync_data_consistency',
-          description: 'AUTONOMOUS data synchronization - fixes data consistency issues by refreshing cache, re-indexing artifacts, and validating sys_id mappings. AUTO-HEALING.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              operation: { type: 'string', enum: ['refresh_cache', 'validate_sysids', 'reindex_artifacts', 'full_sync'], description: 'Type of sync operation' },
-              sys_id: { type: 'string', description: 'Specific sys_id to validate (optional)' },
-              table: { type: 'string', description: 'Specific table to sync (optional)' },
-            },
-            required: ['operation'],
-          },
-        },
-        {
-          name: 'snow_validate_live_connection',
-          description: 'REAL-TIME connection validation - validates live ServiceNow connection, authentication, and permissions. Returns actual instance status and capabilities.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              test_level: { type: 'string', enum: ['basic', 'full', 'permissions'], description: 'Level of validation (basic=ping, full=read test, permissions=write test)', default: 'basic' },
-              include_performance: { type: 'boolean', description: 'Include response time metrics', default: false },
-            },
-          },
-        },
-        {
-          name: 'batch_deployment_validator',
-          description: 'COMPREHENSIVE batch validation - validates multiple deployments simultaneously, checks dependencies, conflicts, and provides rollback recommendations.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              artifacts: { type: 'array', items: { type: 'object', properties: { type: { type: 'string' }, sys_id: { type: 'string' }, table: { type: 'string' } } }, description: 'List of artifacts to validate' },
-              validation_level: { type: 'string', enum: ['syntax', 'dependencies', 'full'], description: 'Level of validation', default: 'full' },
-              check_conflicts: { type: 'boolean', description: 'Check for conflicts between artifacts', default: true },
-            },
-            required: ['artifacts'],
-          },
-        },
-        {
-          name: 'deployment_rollback_manager',
-          description: 'AUTOMATIC rollback management - monitors deployments, detects failures, and provides automatic rollback capabilities with detailed recovery steps.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              update_set_id: { type: 'string', description: 'Update Set sys_id to monitor/rollback' },
-              action: { type: 'string', enum: ['monitor', 'rollback', 'validate_rollback'], description: 'Action to perform' },
-              rollback_reason: { type: 'string', description: 'Reason for rollback (required for rollback action)' },
-              create_backup: { type: 'boolean', description: 'Create backup before rollback', default: true },
-            },
-            required: ['update_set_id', 'action'],
-          },
-        },
-        {
-          name: 'snow_escalate_permissions',
-          description: 'PERMISSION ESCALATION - Request temporary elevated permissions for complex development workflows. Handles admin role requirements automatically.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              required_roles: { type: 'array', items: { type: 'string' }, description: 'Required roles (admin, app_creator, system_administrator)' },
-              duration: { type: 'string', enum: ['session', 'temporary', 'workflow'], description: 'Duration of elevation', default: 'session' },
-              reason: { type: 'string', description: 'Reason for permission escalation' },
-              workflow_context: { type: 'string', description: 'Context of the development workflow requiring elevation' },
-            },
-            required: ['required_roles', 'reason'],
-          },
-        },
-        {
-          name: 'snow_analyze_requirements',
-          description: 'INTELLIGENT REQUIREMENT ANALYSIS - Auto-discovers dependencies, suggests existing components, creates dependency maps for complex objectives.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              objective: { type: 'string', description: 'Development objective (e.g., "iPhone provisioning for new users")' },
-              auto_discover_dependencies: { type: 'boolean', description: 'Automatically discover required dependencies', default: true },
-              suggest_existing_components: { type: 'boolean', description: 'Suggest reuse of existing components', default: true },
-              create_dependency_map: { type: 'boolean', description: 'Create visual dependency map', default: true },
-              scope_preference: { type: 'string', enum: ['global', 'scoped', 'auto'], description: 'Deployment scope preference', default: 'auto' },
-            },
-            required: ['objective'],
-          },
-        },
-        {
-          name: 'snow_smart_update_set',
-          description: 'SMART UPDATE SET MANAGEMENT - Automatic artifact tracking, conflict detection, dependency validation, and rollback points.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              action: { type: 'string', enum: ['create', 'track', 'validate', 'conflict_check'], description: 'Update Set management action' },
-              auto_track_related_artifacts: { type: 'boolean', description: 'Automatically track related artifacts', default: true },
-              conflict_detection: { type: 'boolean', description: 'Enable conflict detection', default: true },
-              dependency_validation: { type: 'boolean', description: 'Validate dependencies', default: true },
-              rollback_points: { type: 'boolean', description: 'Create rollback points', default: true },
-              update_set_name: { type: 'string', description: 'Name for new Update Set (required for create action)' },
-            },
-            required: ['action'],
-          },
-        },
-        {
-          name: 'snow_orchestrate_development',
-          description: 'UNIFIED DEVELOPMENT ORCHESTRATION - Single command for complex workflows with auto-spawning agents, shared memory, and progress monitoring.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              objective: { type: 'string', description: 'Development objective (e.g., "iPhone provisioning workflow")' },
-              auto_spawn_agents: { type: 'boolean', description: 'Automatically spawn required agents', default: true },
-              shared_memory: { type: 'boolean', description: 'Enable shared memory between agents', default: true },
-              parallel_execution: { type: 'boolean', description: 'Enable parallel execution', default: true },
-              progress_monitoring: { type: 'boolean', description: 'Real-time progress monitoring', default: true },
-              auto_permissions: { type: 'boolean', description: 'Automatic permission escalation', default: false },
-              smart_discovery: { type: 'boolean', description: 'Smart artifact discovery and reuse', default: true },
-              live_testing: { type: 'boolean', description: 'Enable live testing during development', default: true },
-              auto_deploy: { type: 'boolean', description: 'Automatic deployment when ready', default: false },
-            },
-            required: ['objective'],
-          },
-        },
-        {
-          name: 'snow_resilient_deployment',
-          description: 'RESILIENT DEPLOYMENT - Advanced error recovery with retry mechanisms, fallback strategies, checkpoints, and graceful degradation.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              artifacts: { type: 'array', items: { type: 'object' }, description: 'Artifacts to deploy' },
-              retry_on_failure: { type: 'boolean', description: 'Enable automatic retry on failure', default: true },
-              fallback_strategies: { type: 'array', items: { type: 'string', enum: ['global_scope', 'manual_approval', 'staged_deployment'] }, description: 'Fallback strategies' },
-              checkpoint_restoration: { type: 'boolean', description: 'Enable checkpoint restoration', default: true },
-              graceful_degradation: { type: 'boolean', description: 'Enable graceful degradation', default: true },
-              max_retries: { type: 'number', description: 'Maximum retry attempts', default: 3 },
-            },
-            required: ['artifacts'],
-          },
-        },
-      ],
-    }));
-
-    // Register tool handlers
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        // Authenticate if needed
-        const authResult = await mcpAuth.ensureAuthenticated();
-        if (!authResult.success) {
-          throw new McpError(ErrorCode.InternalError, authResult.error || 'Authentication required');
-        }
-        
-        switch (name) {
-          case 'snow_find_artifact':
-            return await this.findArtifact(args);
-          case 'snow_edit_artifact':
-            return await this.editArtifact(args);
-          case 'snow_get_by_sysid':
-            return await this.getBySysId(args);
-          case 'snow_edit_by_sysid':
-            return await this.editBySysId(args);
-          case 'snow_analyze_artifact':
-            return await this.analyzeArtifact(args);
-          case 'snow_memory_search':
-            return await this.searchMemory(args);
-          case 'snow_comprehensive_search':
-            return await this.comprehensiveSearch(args);
-          case 'snow_sync_data_consistency':
-            return await this.syncDataConsistency(args);
-          case 'snow_validate_live_connection':
-            return await this.validateLiveConnection(args);
-          case 'batch_deployment_validator':
-            return await this.batchDeploymentValidator(args);
-          case 'deployment_rollback_manager':
-            return await this.deploymentRollbackManager(args);
-          case 'snow_escalate_permissions':
-            return await this.escalatePermissions(args);
-          case 'snow_analyze_requirements':
-            return await this.analyzeRequirements(args);
-          case 'snow_smart_update_set':
-            return await this.smartUpdateSet(args);
-          case 'snow_orchestrate_development':
-            return await this.orchestrateDevelopment(args);
-          case 'snow_resilient_deployment':
-            return await this.resilientDeployment(args);
-          case 'snow_verify_artifact_searchable':
-            return await this.verifyArtifactSearchable(args);
-          case 'snow_generate_documentation':
-            return await this.generateDocumentation(args);
-          case 'snow_documentation_suggestions':
-            return await this.getDocumentationSuggestions(args);
-          case 'snow_start_continuous_documentation':
-            return await this.startContinuousDocumentation(args);
-          case 'snow_analyze_costs':
-            const costRequest: any = {
-              scope: args.scope || 'all',
-              auto_implement: args.auto_implement || false,
-              target_reduction: args.target_reduction,
-              testing_enabled: args.testing_enabled !== false
-            };
-            const costResult = await this.costOptimizationEngine.analyzeCosts(costRequest);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(costResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_cost_dashboard':
-            const dashboardResult = await this.costOptimizationEngine.getCostDashboard();
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(dashboardResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_start_autonomous_cost_optimization':
-            const startResult = await this.costOptimizationEngine.startAutonomousOptimization(args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(startResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_implement_cost_optimization':
-            const implementResult = await this.costOptimizationEngine.implementOptimization(String(args.optimization_id));
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(implementResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_assess_compliance':
-            const complianceResult = await this.complianceSystem.assessCompliance(args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(complianceResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_compliance_dashboard':
-            const complianceDashboard = await this.complianceSystem.getComplianceDashboard();
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(complianceDashboard, null, 2)
-                }
-              ]
-            };
-          case 'snow_start_compliance_monitoring':
-            const monitoringResult = await this.complianceSystem.startContinuousMonitoring(args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: '✅ Compliance monitoring started successfully'
-                }
-              ]
-            };
-          case 'snow_execute_corrective_action':
-            const actionResult = await this.complianceSystem.executeCorrectiveAction(String(args.action_id), args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(actionResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_health_check':
-            const healthResult = await this.selfHealingSystem.performHealthCheck(args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(healthResult, null, 2)
-                }
-              ]
-            };
-          case 'snow_health_dashboard':
-            const healthDashboard = await this.selfHealingSystem.getHealthDashboard();
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(healthDashboard, null, 2)
-                }
-              ]
-            };
-          case 'snow_start_autonomous_healing':
-            const healingStartResult = await this.selfHealingSystem.startAutonomousHealing(args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: '✅ Autonomous healing started successfully'
-                }
-              ]
-            };
-          case 'snow_execute_healing_action':
-            const healingResult = await this.selfHealingSystem.executeHealingAction(String(args.action_id), args);
-            return {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(healingResult, null, 2)
-                }
-              ]
-            };
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        this.logger.error(`Tool execution failed: ${name}`, error);
-        throw new McpError(
-          ErrorCode.InternalError,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    });
-  }
-
-  private async findArtifact(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('🔴 SNOW-002 FIX: Finding ServiceNow artifact with retry logic', { query: args.query });
-
-      // 1. Parse natural language intent
-      const intent = await this.parseIntent(args.query);
-      
-      // 2. Search in memory first
-      const memoryResults = await this.searchInMemory(intent);
-      
-      if (memoryResults.length > 0) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `🧠 Found in memory:\n\n${this.formatResults(memoryResults)}\n\n💡 Using cached intelligent index for optimal performance.`,
-            },
-          ],
-        };
-      }
-
-      // 🔴 CRITICAL FIX: Search ServiceNow with retry logic for newly created artifacts
-      this.logger.info(`🔍 Searching ServiceNow with retry logic for: ${intent.identifier} (type: ${intent.artifactType})`);
-      const liveResults = await this.searchServiceNowWithRetry(intent);
-      this.logger.info(`✅ ServiceNow search with retry returned ${liveResults?.length || 0} results`);
-      
-      // Debug log
-      if (liveResults && liveResults.length > 0) {
-        this.logger.info(`First result: ${JSON.stringify(liveResults[0])}`);
-      }
-      
-      // 4. Index results for future use (only if we have results)
-      if (liveResults && liveResults.length > 0) {
-        this.logger.info('Indexing found artifacts for future use...');
-        for (const result of liveResults) {
-          await this.intelligentlyIndex(result);
-        }
-      }
-
-      const instanceInfo = await mcpAuth.getInstanceInfo();
-      const resultText = this.formatResults(liveResults);
-      this.logger.info(`Formatted result text: ${resultText.substring(0, 200)}...`);
-      const editSuggestion = this.generateEditSuggestion(liveResults?.[0]);
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `🔍 ServiceNow Search Results:\n\n${resultText}\n\n🔗 ServiceNow Instance: ${instanceInfo.instance}\n\n${editSuggestion}`,
-          },
-        ],
-      };
-    } catch (error) {
-      throw new Error(`Artifact search failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  private async editArtifact(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Editing ServiceNow artifact', { query: args.query });
-
-      // 1. Parse edit instruction
-      const editIntent = await this.parseEditIntent(args.query);
-      
-      // 2. Find target artifact
-      const artifact = await this.findTargetArtifact(editIntent);
-      
-      // 3. Analyze modification requirements
-      const modification = await this.analyzeModification(editIntent, artifact);
-      
-      // 4. Apply intelligent modification
-      const editedArtifact = await this.applyModification(artifact, modification);
-      
-      // 5. Deploy back to ServiceNow
-      const deployResult = await this.deployArtifact(editedArtifact);
-      
-      // 6. Update memory with changes
-      await this.updateMemoryIndex(editedArtifact, modification);
-
-      const instanceInfo = await mcpAuth.getInstanceInfo();
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ ServiceNow artifact successfully modified!\n\n🎯 Modification Details:\n- Artifact: ${artifact.name}\n- Type: ${artifact.type}\n- Changes: ${modification.description}\n\n🔗 View in ServiceNow: ${instanceInfo.instance}/nav_to.do?uri=${this.getArtifactUrl(artifact)}\n\n📝 The artifact has been intelligently indexed and is now available for future natural language queries.`,
-          },
-        ],
-      };
-    } catch (error) {
-      throw new Error(`Artifact editing failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  private async analyzeArtifact(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Analyzing ServiceNow artifact', { sys_id: args.sys_id });
-
-      // Fetch complete artifact from ServiceNow
-      const artifact = await this.client.getRecord(args.table, args.sys_id);
-      
-      // Perform intelligent indexing
-      const indexedArtifact = await this.intelligentlyIndex(artifact);
-      
-      // Store in memory
-      await this.storeInMemory(indexedArtifact);
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `🧠 Artifact Analysis Complete!\n\n📋 Summary:\n${indexedArtifact.claudeSummary}\n\n🏗️ Structure:\n${JSON.stringify(indexedArtifact.structure, null, 2)}\n\n🎯 Modification Points:\n${indexedArtifact.modificationPoints.map(p => `- ${p.description}`).join('\n')}\n\n💾 Artifact has been intelligently indexed and stored in memory for future natural language interactions.`,
-          },
-        ],
-      };
-    } catch (error) {
-      throw new Error(`Artifact _analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  private async searchMemory(args: any) {
-    try {
-      const results = await this.searchInMemory({
-        identifier: args.query,
-        artifactType: args.type || 'any',
-        action: 'find',
-        confidence: 0.8
-      });
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `🧠 Memory Search Results:\n\n${this.formatMemoryResults(results)}\n\n💡 All results are from the intelligent index for instant access.`,
-          },
-        ],
-      };
-    } catch (error) {
-      throw new Error(`Memory search failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  private async comprehensiveSearch(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Starting comprehensive search', { query: args.query });
-
-      // Define tables to search with their descriptions
-      const searchTables = [
-        { name: 'sys_script', desc: 'Business Rules', type: 'business_rule' },
-        { name: 'sys_script_include', desc: 'Script Includes', type: 'script_include' },
-        { name: 'sys_script_client', desc: 'Client Scripts', type: 'client_script' },
-        { name: 'sys_ui_script', desc: 'UI Scripts', type: 'ui_script' },
-        { name: 'sp_widget', desc: 'Service Portal Widgets', type: 'widget' },
-        { name: 'sys_hub_flow', desc: 'Flow Designer Flows', type: 'flow' },
-        { name: 'wf_workflow', desc: 'Workflows', type: 'workflow' },
-        { name: 'sys_ui_action', desc: 'UI Actions', type: 'ui_action' },
-        { name: 'sys_ui_policy', desc: 'UI Policies', type: 'ui_policy' },
-        { name: 'sys_data_policy', desc: 'Data Policies', type: 'data_policy' },
-        { name: 'sys_app_application', desc: 'Applications', type: 'application' },
-        { name: 'sys_db_object', desc: 'Tables', type: 'table' },
-        { name: 'sys_dictionary', desc: 'Dictionary/Fields', type: 'field' },
-        { name: 'sysevent_email_action', desc: 'Notifications', type: 'notification' },
-        { name: 'sys_transform_map', desc: 'Transform Maps', type: 'transform_map' },
-        { name: 'sys_ws_definition', desc: 'REST APIs', type: 'rest_api' },
-        { name: 'sc_cat_item', desc: 'Catalog Items', type: 'catalog_item' },
-        { name: 'sc_catalog', desc: 'Service Catalogs', type: 'catalog' },
-        { name: 'sc_category', desc: 'Catalog Categories', type: 'catalog_category' },
-        { name: 'item_option_new', desc: 'Catalog Variables', type: 'catalog_variable' },
-      ];
-
-      const searchString = args.query.trim();
-      const allResults = [];
-
-      // Generate multiple search strategies like Claude Code did
-      const searchStrategies = [
-        { query: `name=${searchString}`, desc: 'Exact name match' },
-        { query: `nameLIKE${searchString}`, desc: 'Name contains' },
-        { query: `short_descriptionLIKE${searchString}`, desc: 'Description contains' },
-        { query: `nameLIKE${searchString}^ORshort_descriptionLIKE${searchString}`, desc: 'Name or description' },
-      ];
-
-      // Add wildcard searches if multiple words
-      const words = searchString.split(' ').filter((w: string) => w.length > 2);
-      if (words.length > 1) {
-        const firstWord = words[0];
-        const lastWord = words[words.length - 1];
-        searchStrategies.push({ 
-          query: `nameLIKE*${firstWord}*${lastWord}*`, 
-          desc: 'First and last word match' 
-        });
-      }
-
-      // 🔴 SNOW-002 FIX: Apply retry logic to comprehensive search as well
-      for (const table of searchTables) {
-        this.logger.info(`🔴 SNOW-002 FIX: Searching ${table.desc} (${table.name}) with retry logic...`);
-        
-        // Try search with retry logic for each table
-        const tableResults = [];
-        const maxTableRetries = 3; // Shorter retry for comprehensive search
-        
-        for (let attempt = 1; attempt <= maxTableRetries; attempt++) {
-          let foundResults = false;
-          
-          for (const strategy of searchStrategies) {
-            try {
-              const activeFilter = args.include_inactive ? '' : '^active=true';
-              const fullQuery = `${strategy.query}${activeFilter}^LIMIT5`;
-              
-              const results = await this.client.searchRecords(table.name, fullQuery);
-              
-              if (results && results.success && results.data.result.length > 0) {
-                // Add metadata to results
-                const enhancedResults = results.data.result.map((result: any) => ({
-                  ...result,
-                  artifact_type: table.type,
-                  table_name: table.name,
-                  table_description: table.desc,
-                  search_strategy: strategy.desc,
-                  retry_attempt: attempt
-                }));
-                
-                tableResults.push(...enhancedResults);
-                foundResults = true;
-                
-                // Stop searching this table if we found results
-                break;
-              }
-            } catch (error) {
-              this.logger.warn(`Error searching ${table.name} (attempt ${attempt}):`, error);
-            }
-          }
-          
-          // If we found results, stop retrying this table
-          if (foundResults) {
-            break;
-          }
-          
-          // If no results and not the last attempt, wait before retry
-          if (attempt < maxTableRetries) {
-            const delay = 800 * attempt; // Shorter delays: 800ms, 1600ms
-            this.logger.info(`🔄 No results for ${table.name}, waiting ${delay}ms before retry...`);
-            await this.sleep(delay);
-          }
-        }
-        
-        // Add any results found for this table
-        allResults.push(...tableResults);
-      }
-
-      // Remove duplicates by sys_id
-      const uniqueResults = allResults.filter((result, index, self) => 
-        index === self.findIndex(r => r.sys_id === result.sys_id)
-      );
-
-      const instanceInfo = await mcpAuth.getInstanceInfo();
-      const resultText = this.formatComprehensiveResults(uniqueResults);
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `🔍 Comprehensive ServiceNow Search Results:\n\n${resultText}\n\n🔗 ServiceNow Instance: ${instanceInfo.instance}\n\n💡 Searched across ${searchTables.length} table types with multiple strategies.`,
-          },
-        ],
-      };
-    } catch (error) {
-      throw new Error(`Comprehensive search failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  private async parseIntent(query: string): Promise<ParsedIntent> {
-    // Enhanced intent parsing with comprehensive type detection
-    const lowercaseQuery = query.toLowerCase();
-    
-    let artifactType = 'any'; // Default to searching all types
-    
-    // Check for specific artifact types (order matters - most specific first)
-    
-    // Service Portal
-    if (lowercaseQuery.includes('widget')) artifactType = 'widget';
-    else if (lowercaseQuery.includes('portal')) artifactType = 'portal';
-    else if (lowercaseQuery.includes('page') && lowercaseQuery.includes('service')) artifactType = 'page';
-    else if (lowercaseQuery.includes('theme')) artifactType = 'theme';
-    
-    // Flow Designer & Workflow
-    else if (lowercaseQuery.includes('flow designer') || lowercaseQuery.includes('sys_hub_flow')) artifactType = 'flow';
-    else if (lowercaseQuery.includes('workflow') && !lowercaseQuery.includes('orchestration')) artifactType = 'workflow';
-    else if (lowercaseQuery.includes('workflow activity')) artifactType = 'workflow_activity';
-    else if (lowercaseQuery.includes('flow')) artifactType = 'flow';
-    
-    // Scripts & Automation (most specific first)
-    else if (lowercaseQuery.includes('script include')) artifactType = 'script_include';
-    else if (lowercaseQuery.includes('business rule')) artifactType = 'business_rule';
-    else if (lowercaseQuery.includes('client script')) artifactType = 'client_script';
-    else if (lowercaseQuery.includes('ui script')) artifactType = 'ui_script';
-    else if (lowercaseQuery.includes('ui action')) artifactType = 'ui_action';
-    else if (lowercaseQuery.includes('ui policy action')) artifactType = 'ui_policy_action';
-    else if (lowercaseQuery.includes('ui policy')) artifactType = 'ui_policy';
-    else if (lowercaseQuery.includes('data policy rule')) artifactType = 'data_policy_rule';
-    else if (lowercaseQuery.includes('data policy')) artifactType = 'data_policy';
-    
-    // Applications
-    else if (lowercaseQuery.includes('scoped app')) artifactType = 'scoped_app';
-    else if (lowercaseQuery.includes('application') || lowercaseQuery.includes('app')) artifactType = 'application';
-    
-    // Tables & Fields
-    else if (lowercaseQuery.includes('field') || lowercaseQuery.includes('dictionary')) artifactType = 'field';
-    else if (lowercaseQuery.includes('table')) artifactType = 'table';
-    
-    // Forms & UI
-    else if (lowercaseQuery.includes('form section')) artifactType = 'form_section';
-    else if (lowercaseQuery.includes('list control')) artifactType = 'list_control';
-    else if (lowercaseQuery.includes('related list')) artifactType = 'related_list';
-    else if (lowercaseQuery.includes('form')) artifactType = 'form';
-    else if (lowercaseQuery.includes('list')) artifactType = 'list';
-    else if (lowercaseQuery.includes('view')) artifactType = 'view';
-    else if (lowercaseQuery.includes('formatter')) artifactType = 'formatter';
-    
-    // Reports & Dashboards
-    else if (lowercaseQuery.includes('pa dashboard')) artifactType = 'pa_dashboard';
-    else if (lowercaseQuery.includes('pa widget')) artifactType = 'pa_widget';
-    else if (lowercaseQuery.includes('dashboard')) artifactType = 'dashboard';
-    else if (lowercaseQuery.includes('report')) artifactType = 'report';
-    else if (lowercaseQuery.includes('gauge')) artifactType = 'gauge';
-    else if (lowercaseQuery.includes('chart')) artifactType = 'chart';
-    else if (lowercaseQuery.includes('indicator')) artifactType = 'indicator';
-    
-    // Security & Access Control
-    else if (lowercaseQuery.includes('acl') || lowercaseQuery.includes('access control')) artifactType = 'acl';
-    else if (lowercaseQuery.includes('role')) artifactType = 'role';
-    else if (lowercaseQuery.includes('group')) artifactType = 'group';
-    
-    // Notifications & Communication
-    else if (lowercaseQuery.includes('email template')) artifactType = 'email_template';
-    else if (lowercaseQuery.includes('notification')) artifactType = 'notification';
-    
-    // Import & Export
-    else if (lowercaseQuery.includes('import set')) artifactType = 'import_set';
-    else if (lowercaseQuery.includes('transform map')) artifactType = 'transform_map';
-    
-    // Web Services
-    else if (lowercaseQuery.includes('rest api') || lowercaseQuery.includes('rest')) artifactType = 'rest_api';
-    else if (lowercaseQuery.includes('soap api') || lowercaseQuery.includes('soap')) artifactType = 'soap_api';
-    
-    // Scheduled Jobs
-    else if (lowercaseQuery.includes('scheduled job')) artifactType = 'scheduled_job';
-    else if (lowercaseQuery.includes('scheduled import')) artifactType = 'scheduled_import';
-    
-    // Knowledge Management
-    else if (lowercaseQuery.includes('knowledge base')) artifactType = 'knowledge_base';
-    else if (lowercaseQuery.includes('knowledge article') || lowercaseQuery.includes('knowledge')) artifactType = 'knowledge_article';
-    
-    // System Administration
-    else if (lowercaseQuery.includes('system property') || lowercaseQuery.includes('property')) artifactType = 'property';
-    
-    // Mobile
-    else if (lowercaseQuery.includes('mobile app') || lowercaseQuery.includes('mobile')) artifactType = 'mobile_app';
-    
-    // Catalog
-    else if (lowercaseQuery.includes('catalog item')) artifactType = 'catalog_item';
-    else if (lowercaseQuery.includes('catalog variable')) artifactType = 'catalog_variable';
-    else if (lowercaseQuery.includes('catalog')) artifactType = 'catalog';
-    
-    // SLA & Metrics
-    else if (lowercaseQuery.includes('sla')) artifactType = 'sla';
-    else if (lowercaseQuery.includes('metric')) artifactType = 'metric';
-    
-    // Other common types
-    else if (lowercaseQuery.includes('attachment')) artifactType = 'attachment';
-    else if (lowercaseQuery.includes('language')) artifactType = 'language';
-    else if (lowercaseQuery.includes('translation')) artifactType = 'translated_text';
-    else if (lowercaseQuery.includes('processor')) artifactType = 'processor';
-    else if (lowercaseQuery.includes('update set')) artifactType = 'update_set';
-    else if (lowercaseQuery.includes('ml model') || lowercaseQuery.includes('machine learning')) artifactType = 'ml_model';
-    else if (lowercaseQuery.includes('spoke')) artifactType = 'spoke';
-    else if (lowercaseQuery.includes('connection')) artifactType = 'connection';
-    else if (lowercaseQuery.includes('virtual agent') || lowercaseQuery.includes('chatbot')) artifactType = 'virtual_agent';
-    else if (lowercaseQuery.includes('event rule')) artifactType = 'event_rule';
-    else if (lowercaseQuery.includes('alert')) artifactType = 'alert';
-    else if (lowercaseQuery.includes('discovery')) artifactType = 'discovery_schedule';
-    else if (lowercaseQuery.includes('ci class')) artifactType = 'ci_class';
-    else if (lowercaseQuery.includes('relationship')) artifactType = 'relationship_type';
-    else if (lowercaseQuery.includes('service map')) artifactType = 'service_map';
-    else if (lowercaseQuery.includes('orchestration workflow')) artifactType = 'orchestration_workflow';
-    else if (lowercaseQuery.includes('pipeline')) artifactType = 'pipeline';
-    else if (lowercaseQuery.includes('deployment')) artifactType = 'deployment';
-    
-    // Generic fallbacks
-    else if (lowercaseQuery.includes('script')) artifactType = 'script_include';
-
-    // Smart identifier extraction - remove artifact type keywords and get the actual name
-    const identifier = this.extractIdentifier(query, artifactType);
-    
-    return {
-      action: 'find',
-      artifactType,
-      identifier,
-      confidence: 0.9,
-    };
-  }
-
-  private extractIdentifier(query: string, artifactType: string): string {
-    // Smart extraction of actual artifact name by removing type keywords
-    let identifier = query.toLowerCase().trim();
-    
-    // Remove common artifact type keywords
-    const typeKeywords = [
-      'widget', 'portal', 'page', 'theme',
-      'flow designer', 'sys_hub_flow', 'workflow', 'workflow activity', 'flow',
-      'script include', 'business rule', 'client script', 'ui script', 'ui action',
-      'ui policy action', 'ui policy', 'data policy rule', 'data policy',
-      'scoped app', 'application', 'app',
-      'field', 'dictionary', 'table',
-      'form section', 'list control', 'related list', 'form', 'list', 'view', 'formatter',
-      'pa dashboard', 'report', 'dashboard', 'gauge', 'indicator',
-      'sla', 'metric', 'attachment', 'language', 'translation', 'processor',
-      'update set', 'ml model', 'machine learning', 'spoke', 'connection',
-      'virtual agent', 'chatbot', 'event rule', 'alert', 'discovery',
-      'ci class', 'relationship', 'service map', 'orchestration workflow',
-      'pipeline', 'deployment', 'script'
-    ];
-    
-    // Remove type keywords and common words
-    const wordsToRemove = [
-      ...typeKeywords,
-      'the', 'a', 'an', 'with', 'that', 'shows', 'displays', 'for', 'on', 'in',
-      'servicenow', 'snow', 'sys_id:', 'system', 'id'
-    ];
-    
-    // Remove sys_id if present (extract it separately)
-    const sysIdMatch = identifier.match(/sys_id:\s*([a-f0-9]{32})/);
-    if (sysIdMatch) {
-      // If we have a sys_id, prioritize that
-      return sysIdMatch[1];
-    }
-    
-    // Remove words to clean up the identifier
-    for (const word of wordsToRemove) {
-      const regex = new RegExp(`\\b${word}\\b`, 'gi');
-      identifier = identifier.replace(regex, ' ');
-    }
-    
-    // Clean up whitespace and return
-    identifier = identifier.replace(/\s+/g, ' ').trim();
-    
-    // If identifier is empty or too short, return original query
-    if (!identifier || identifier.length < 2) {
-      return query.trim();
-    }
-    
-    return identifier;
-  }
-
-  private async parseEditIntent(query: string): Promise<ParsedIntent & { modification: string }> {
-    // Parse edit instructions - would be more sophisticated in real implementation
-    const intent = await this.parseIntent(query);
-    
-    return {
-      ...intent,
-      action: 'edit',
-      modification: query,
-    };
-  }
-
-  /**
-   * 🔴 CRITICAL FIX SNOW-002: Search ServiceNow with retry logic for newly created artifacts
-   * Addresses: "I created a flow but search says it doesn't exist"
-   * Root Cause: ServiceNow search indexes take time to update after artifact creation
-   */
-  private async searchServiceNowWithRetry(intent: ParsedIntent): Promise<any[]> {
-    const maxRetries = 5;
-    const baseDelay = 1500; // Start with 1.5 seconds
-    
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        this.logger.info(`🔍 Search attempt ${attempt}/${maxRetries} for: ${intent.identifier}`);
-        
-        // Try the regular search
-        const results = await this.searchServiceNow(intent);
-        
-        if (results && results.length > 0) {
-          this.logger.info(`✅ Found ${results.length} results on attempt ${attempt}`);
-          return results;
-        }
-        
-        // If no results and not the last attempt, wait and retry
-        if (attempt < maxRetries) {
-          const delay = baseDelay * attempt; // 1.5s, 3s, 4.5s, 6s, 7.5s
-          this.logger.info(`🔄 No results found, waiting ${delay}ms before retry (ServiceNow indexes may be updating...)`);
-          await this.sleep(delay);
-          
-          // 🔴 CRITICAL: Try cache invalidation on ServiceNow side
-          if (attempt === 2) {
-            this.logger.info('🔄 Attempting ServiceNow cache refresh...');
-            await this.attemptCacheRefresh(intent);
-          }
-        }
-        
-      } catch (error) {
-        this.logger.warn(`Search attempt ${attempt} failed:`, error);
-        
-        // If this is the last attempt, throw the error
-        if (attempt === maxRetries) {
-          throw error;
-        }
-        
-        // Otherwise wait and retry
-        const delay = baseDelay * attempt;
-        this.logger.info(`⏳ Waiting ${delay}ms before retry due to error`);
-        await this.sleep(delay);
-      }
-    }
-    
-    // 🔴 CRITICAL: If all retries failed, try broad fallback search
-    this.logger.warn('🚨 All retry attempts failed, trying broad fallback search...');
-    return await this.broadFallbackSearch(intent);
-  }
-
-  /**
-   * 🔴 SNOW-002 FIX: Attempt to refresh ServiceNow caches
-   */
-  private async attemptCacheRefresh(intent: ParsedIntent): Promise<void> {
-    try {
-      const tableMapping: Record<string, string> = {
-        widget: 'sp_widget',
-        flow: 'sys_hub_flow',
-        script: 'sys_script_include',
-        application: 'sys_app_application'
-      };
-      
-      const table = tableMapping[intent.artifactType] || 'sys_hub_flow';
-      
-      // Try a simple count query to potentially refresh indexes
-      await this.client.searchRecords(table, 'sys_id!=null^LIMIT1');
-      this.logger.info('✨ Cache refresh attempt completed');
-      
-    } catch (error) {
-      this.logger.warn('Cache refresh attempt failed:', error);
-    }
-  }
-
-  /**
-   * 🔴 SNOW-002 FIX: Broad fallback search when all retries fail
-   */
-  private async broadFallbackSearch(intent: ParsedIntent): Promise<any[]> {
-    this.logger.info('🔍 Attempting broad fallback search across multiple tables...');
-    
-    try {
-      // Search across multiple related tables
-      const broadResults = [];
-      const searchTerm = intent.identifier.trim();
-      
-      // Define broader table search for common artifacts
-      const fallbackTables = [
-        'sys_hub_flow', 'sp_widget', 'sys_script_include', 
-        'sys_script', 'sys_app_application', 'wf_workflow'
-      ];
-      
-      for (const table of fallbackTables) {
-        try {
-          // Try multiple search strategies
-          const strategies = [
-            `nameLIKE*${searchTerm}*^LIMIT3`,
-            `titleLIKE*${searchTerm}*^LIMIT3`,
-            `short_descriptionLIKE*${searchTerm}*^LIMIT3`
-          ];
-          
-          for (const query of strategies) {
-            const results = await this.client.searchRecords(table, query);
-            if (results && results.success && results.data.result.length > 0) {
-              const typedResults = results.data.result.map((result: any) => ({
-                ...result,
-                table_name: table,
-                search_fallback: true
-              }));
-              broadResults.push(...typedResults);
-            }
-          }
-        } catch (error) {
-          this.logger.warn(`Fallback search failed for ${table}:`, error);
-        }
-      }
-      
-      // Remove duplicates and return
-      const uniqueResults = broadResults.filter((result, index, self) => 
-        index === self.findIndex(r => r.sys_id === result.sys_id)
-      );
-      
-      this.logger.info(`🔍 Fallback search found ${uniqueResults.length} results`);
-      return uniqueResults;
-      
-    } catch (error) {
-      this.logger.error('Broad fallback search failed:', error);
-      return [];
-    }
-  }
-
-  /**
-   * 🔴 SNOW-002 FIX: Special search method for newly created artifacts
-   * Use this immediately after creating an artifact to verify it's searchable
-   */
-  async searchForRecentlyCreatedArtifact(artifactName: string, artifactType: string, expectedSysId?: string): Promise<any[]> {
-    this.logger.info(`🔍 SNOW-002: Searching for recently created artifact: ${artifactName} (${artifactType})`);
-    
-    const intent: ParsedIntent = {
-      identifier: artifactName,
-      artifactType: artifactType,
-      action: 'find',
-      confidence: 0.9
-    };
-    
-    // First try the sys_id lookup if we have it (most reliable)
-    if (expectedSysId) {
-      try {
-        this.logger.info(`🎯 Trying direct sys_id lookup: ${expectedSysId}`);
-        const tableMapping: Record<string, string> = {
-          widget: 'sp_widget',
-          flow: 'sys_hub_flow',
-          script: 'sys_script_include',
-          application: 'sys_app_application'
-        };
-        
-        const table = tableMapping[artifactType] || 'sys_hub_flow';
-        const directResult = await this.client.searchRecords(table, `sys_id=${expectedSysId}`);
-        
-        if (directResult && directResult.success && directResult.data.result.length > 0) {
-          this.logger.info(`✅ Found via direct sys_id lookup`);
-          return directResult.data.result;
-        }
-      } catch (error) {
-        this.logger.warn('Direct sys_id lookup failed:', error);
-      }
-    }
-    
-    // Fall back to name-based search with extended retry logic
-    const maxRetries = 7; // More retries for newly created artifacts
-    const baseDelay = 2000; // Longer initial delay (2 seconds)
-    
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        this.logger.info(`🔍 Post-creation search attempt ${attempt}/${maxRetries}`);
-        
-        const results = await this.searchServiceNow(intent);
-        
-        if (results && results.length > 0) {
-          this.logger.info(`✅ SNOW-002 RESOLVED: Found ${results.length} results for newly created artifact on attempt ${attempt}`);
-          return results;
-        }
-        
-        if (attempt < maxRetries) {
-          // Progressive delay with jitter: 2s, 4s, 6s, 8s, 10s, 12s, 14s
-          const delay = baseDelay * attempt;
-          this.logger.info(`🔄 Artifact not yet searchable, waiting ${delay}ms (ServiceNow indexes updating...)`);
-          await this.sleep(delay);
-          
-          // Try cache refresh on every other attempt
-          if (attempt % 2 === 0) {
-            await this.attemptCacheRefresh(intent);
-          }
-        }
-        
-      } catch (error) {
-        this.logger.warn(`Post-creation search attempt ${attempt} failed:`, error);
-        
-        if (attempt < maxRetries) {
-          const delay = baseDelay * attempt;
-          await this.sleep(delay);
-        }
-      }
-    }
-    
-    this.logger.warn('🚨 SNOW-002: Recently created artifact still not searchable after all retries');
-    return [];
-  }
-
-  /**
-   * Sleep utility for retry delays
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  private async searchServiceNow(intent: ParsedIntent) {
-    try {
-      const tableMapping: Record<string, string> = {
-        // Service Portal
-        widget: 'sp_widget',
-        portal: 'sp_portal',
-        page: 'sp_page',
-        theme: 'sp_theme',
-        
-        // Flow Designer & Workflow
-        flow: 'sys_hub_flow',
-        workflow: 'wf_workflow',
-        workflow_activity: 'wf_activity',
-        
-        // Scripts & Automation
-        script_include: 'sys_script_include',
-        script: 'sys_script_include',
-        business_rule: 'sys_script',
-        client_script: 'sys_script_client',
-        ui_script: 'sys_ui_script',
-        ui_action: 'sys_ui_action',
-        ui_policy: 'sys_ui_policy',
-        ui_policy_action: 'sys_ui_policy_action',
-        data_policy: 'sys_data_policy',
-        data_policy_rule: 'sys_data_policy_rule',
-        
-        // Applications & Scoped Apps
-        application: 'sys_app_application',
-        app: 'sys_app_application',
-        scoped_app: 'sys_app',
-        
-        // Tables & Fields
-        table: 'sys_db_object',
-        field: 'sys_dictionary',
-        dictionary: 'sys_dictionary',
-        
-        // Forms & UI
-        form: 'sys_form',
-        form_section: 'sys_form_section',
-        list: 'sys_list',
-        list_control: 'sys_list_control',
-        view: 'sys_ui_view',
-        related_list: 'sys_ui_related_list',
-        formatter: 'sys_ui_formatter',
-        
-        // Reports & Dashboards
-        report: 'sys_report',
-        dashboard: 'sys_dashboard',
-        gauge: 'pa_dashboards',
-        chart: 'sys_chart',
-        
-        // Security & Access Control
-        acl: 'sys_security_acl',
-        role: 'sys_user_role',
-        group: 'sys_user_group',
-        
-        // Notifications & Communication
-        notification: 'sysevent_email_action',
-        email_template: 'sysevent_email_template',
-        
-        // Import & Export
-        import_set: 'sys_import_set',
-        transform_map: 'sys_transform_map',
-        
-        // Web Services
-        rest_api: 'sys_ws_definition',
-        soap_api: 'sys_web_service',
-        
-        // Scheduled Jobs
-        scheduled_job: 'sysauto_script',
-        scheduled_import: 'scheduled_import_set',
-        
-        // Knowledge Management
-        knowledge_base: 'kb_knowledge_base',
-        knowledge_article: 'kb_knowledge',
-        
-        // System Administration
-        property: 'sys_properties',
-        system_property: 'sys_properties',
-        
-        // Mobile
-        mobile_app: 'sys_mobile_application',
-        
-        // Catalog
-        catalog: 'sc_catalog',
-        catalog_item: 'sc_cat_item',
-        catalog_variable: 'item_option_new',
-        
-        // SLA & Metrics
-        sla: 'contract_sla',
-        metric: 'sys_report_color',
-        
-        // Attachments & Files
-        attachment: 'sys_attachment',
-        
-        // Languages & Translations
-        language: 'sys_language',
-        translated_text: 'sys_translated',
-        
-        // Processors & Servlets
-        processor: 'sys_processor',
-        
-        // Update Sets & Deployment
-        update_set: 'sys_update_set',
-        
-        // AI & ML
-        ml_model: 'ml_model',
-        
-        // Integration Hub
-        spoke: 'sys_hub_action_type',
-        connection: 'sys_connection',
-        
-        // Virtual Agent
-        virtual_agent: 'sys_cs_topic',
-        chatbot: 'sys_cs_topic',
-        
-        // Performance Analytics
-        pa_dashboard: 'pa_dashboards',
-        pa_widget: 'pa_widgets',
-        indicator: 'pa_indicators',
-        
-        // Event Management
-        event_rule: 'em_event_rule',
-        alert: 'em_alert',
-        
-        // Discovery
-        discovery_schedule: 'discovery_schedule',
-        
-        // CMDB
-        ci_class: 'sys_db_object',
-        relationship_type: 'cmdb_rel_type',
-        
-        // Service Mapping
-        service_map: 'sa_pattern',
-        
-        // Orchestration
-        orchestration_workflow: 'sc_ic_workflow',
-        
-        // DevOps
-        pipeline: 'cicd_pipeline',
-        deployment: 'cicd_deployment',
-      };
-
-      // If searching for 'any' type, search only the most common tables
-      if (intent.artifactType === 'any') {
-        this.logger.info('Searching common artifact types...');
-        const allResults = [];
-        
-        // Handle "list all" queries for any type
-        const searchString = intent.identifier.trim();
-        if (searchString.toLowerCase().includes('list all') || 
-            searchString.toLowerCase().includes('all artifacts') ||
-            searchString.toLowerCase().includes('show all') ||
-            searchString === '') {
-          this.logger.info('Fetching all common artifact types');
-          
-          // Define most common tables to list when showing all
-          const commonTables = {
-            widget: 'sp_widget',
-            business_rule: 'sys_script',
-            client_script: 'sys_script_client',
-            script_include: 'sys_script_include',
-            flow: 'sys_hub_flow',
-            workflow: 'wf_workflow',
-            ui_action: 'sys_ui_action',
-            table: 'sys_db_object',
-            application: 'sys_app_application',
-          };
-          
-          for (const [type, table] of Object.entries(commonTables)) {
-            try {
-              const results = await this.client.searchRecords(table, `active=true^ORDERBYname^LIMIT10`);
-              if (results && results.success && results.data.result.length > 0) {
-                const typedResults = results.data.result.map((result: any) => ({
-                  ...result,
-                  artifact_type: type,
-                  table_name: table
-                }));
-                allResults.push(...typedResults);
-              }
-            } catch (error) {
-              this.logger.warn(`Error fetching ${table}:`, error);
-            }
-          }
-          
-          return allResults;
-        }
-        
-        // Define most common tables to search when type is 'any'
-        const commonTables = {
-          widget: 'sp_widget',
-          business_rule: 'sys_script',
-          client_script: 'sys_script_client',
-          script_include: 'sys_script_include',
-          flow: 'sys_hub_flow',
-          workflow: 'wf_workflow',
-          ui_action: 'sys_ui_action',
-          table: 'sys_db_object',
-          application: 'sys_app_application',
-        };
-        
-        for (const [type, table] of Object.entries(commonTables)) {
-          try {
-            // Try exact match first for each table
-            const searchString = intent.identifier.trim();
-            let results = await this.client.searchRecords(table, `name=${searchString}^LIMIT2`);
-            
-            // If no exact match, try contains
-            if (!results || !results.success || results.data.result.length === 0) {
-              results = await this.client.searchRecords(table, `nameLIKE${searchString}^LIMIT3`);
-            }
-            
-            // If still no results, try wildcards on first term only
-            if (!results || !results.success || results.data.result.length === 0) {
-              const firstTerm = searchString.split(' ')[0];
-              if (firstTerm && firstTerm.length > 2) {
-                results = await this.client.searchRecords(table, `nameLIKE*${firstTerm}*^LIMIT3`);
-              }
-            }
-            
-            if (results && results.success && results.data.result.length > 0) {
-              // Add artifact type to results for identification
-              const typedResults = results.data.result.map((result: any) => ({
-                ...result,
-                artifact_type: type,
-                table_name: table
-              }));
-              allResults.push(...typedResults);
-            }
-          } catch (error) {
-            this.logger.warn(`Error searching ${table}:`, error);
-          }
-        }
-        
-        // If still no results, try broader search in common tables only
-        if (allResults.length === 0) {
-          this.logger.info('No results found, trying broader search in common tables...');
-          const firstTerm = intent.identifier.split(' ')[0];
-          if (firstTerm && firstTerm.length > 2) {
-            for (const [type, table] of Object.entries(commonTables)) {
-              try {
-                const broadQuery = `(nameLIKE*${firstTerm}*^ORtitleLIKE*${firstTerm}*^ORshort_descriptionLIKE*${firstTerm}*)^LIMIT5`;
-                const results = await this.client.searchRecords(table, broadQuery, 5);
-                if (results && results.success && results.data.result.length > 0) {
-                  const typedResults = results.data.result.map((result: any) => ({
-                    ...result,
-                    artifact_type: type,
-                    table_name: table
-                  }));
-                  allResults.push(...typedResults);
-                }
-              } catch (error) {
-                this.logger.warn(`Error in broad search ${table}:`, error);
-              }
-            }
-          }
-        }
-        
-        return allResults;
-      }
-
-      // Search specific table
-      const table = tableMapping[intent.artifactType];
-      if (!table) {
-        this.logger.warn(`Unknown artifact type: ${intent.artifactType}`);
-        return [];
-      }
-
-      // First try exact match
-      const searchString = intent.identifier.trim();
-      let results: any;
-      
-      // Handle "list all" queries
-      if (searchString.toLowerCase().includes('list all') || 
-          searchString.toLowerCase().includes('all flows') ||
-          searchString.toLowerCase().includes('show all') ||
-          searchString === '') {
-        this.logger.info(`Fetching all ${intent.artifactType} records`);
-        // Get all active records of this type, sorted by name
-        results = await this.client.searchRecords(table, `active=true^ORDERBYname^LIMIT50`);
-        
-        // Add artifact type to results
-        if (results && results.success && results.data.result.length > 0) {
-          const enhancedResults = results.data.result.map((result: any) => ({
-            ...result,
-            artifact_type: intent.artifactType,
-            table_name: table
-          }));
-          return enhancedResults;
-        }
-        
-        return [];
-      }
-      
-      // Try exact name match first
-      this.logger.info(`Trying exact match: name=${searchString}`);
-      results = await this.client.searchRecords(table, `name=${searchString}^LIMIT5`);
-      
-      // If no exact match, try contains without wildcards (ServiceNow specific)
-      if (!results || !results.success || results.data.result.length === 0) {
-        this.logger.info(`No exact match, trying contains: nameLIKE${searchString}`);
-        results = await this.client.searchRecords(table, `nameLIKE${searchString}^LIMIT10`);
-      }
-      
-      // Also try description fields
-      if (!results || !results.success || results.data.result.length === 0) {
-        this.logger.info(`No name match, trying description: short_descriptionLIKE${searchString}`);
-        results = await this.client.searchRecords(table, `short_descriptionLIKE${searchString}^ORdescriptionLIKE${searchString}^LIMIT10`);
-      }
-      
-      // If still no results, use the complex query
-      if (!results || !results.success || results.data.result.length === 0) {
-        const query = this.buildServiceNowQuery(intent);
-        this.logger.info(`No contains match, trying complex query: ${query}`);
-        results = await this.client.searchRecords(table, query);
-      }
-      
-      // If still no results, try a broader search
-      if (!results || !results.success || results.data.result.length === 0) {
-        this.logger.info(`No results found, trying broader search...`);
-        
-        // Try searching with just the first search term with wildcards
-        const firstTerm = intent.identifier.split(' ')[0];
-        if (firstTerm && firstTerm.length > 2) {
-          const broadQuery = `(nameLIKE*${firstTerm}*^ORtitleLIKE*${firstTerm}*^ORshort_descriptionLIKE*${firstTerm}*)^LIMIT10`;
-          results = await this.client.searchRecords(table, broadQuery);
-        }
-        
-        // If still no results, return empty array instead of sample records
-        if (!results || !results.success || results.data.result.length === 0) {
-          this.logger.info(`No results found for search term: ${searchString}`);
-          return [];
-        }
-      }
-
-      // Ensure we always return an array
-      return (results && results.success && results.data.result) ? results.data.result : [];
-    } catch (error) {
-      this.logger.error('Error searching ServiceNow', error);
-      return [];
-    }
-  }
-
-  private buildServiceNowQuery(intent: ParsedIntent): string {
-    // Build proper ServiceNow encoded query
-    const searchString = intent.identifier.trim();
-    
-    if (searchString.length === 0) {
-      // Return first 10 active records if no search terms
-      return 'active=true^LIMIT10';
-    }
-
-    // First try exact name match
-    const exactQuery = `name=${searchString}`;
-    
-    // Then try name contains (without wildcards for multi-word)
-    const containsQuery = `nameLIKE${searchString}`;
-    
-    // For single words, use wildcards (keep original case for better matching)
-    const searchTerms = searchString.split(' ').filter(term => term.length > 1);
-    const wildcardQueries = [];
-    
-    if (searchTerms.length === 1) {
-      // Single word - use wildcards with both cases
-      const term = searchTerms[0];
-      const termLower = term.toLowerCase();
-      wildcardQueries.push(`nameLIKE*${term}*`);
-      wildcardQueries.push(`nameLIKE*${termLower}*`);
-      wildcardQueries.push(`titleLIKE*${term}*`);
-      wildcardQueries.push(`titleLIKE*${termLower}*`);
-      wildcardQueries.push(`short_descriptionLIKE*${termLower}*`);
-    } else {
-      // Multiple words - search for first and last word with wildcards
-      const firstTerm = searchTerms[0];
-      const lastTerm = searchTerms[searchTerms.length - 1];
-      const firstLower = firstTerm.toLowerCase();
-      const lastLower = lastTerm.toLowerCase();
-      
-      wildcardQueries.push(`nameLIKE*${firstTerm}*`);
-      wildcardQueries.push(`nameLIKE*${firstLower}*`);
-      wildcardQueries.push(`nameLIKE*${lastTerm}*`);
-      wildcardQueries.push(`nameLIKE*${lastLower}*`);
-      wildcardQueries.push(`titleLIKE*${firstTerm}*`);
-      wildcardQueries.push(`titleLIKE*${lastTerm}*`);
-    }
-    
-    // Combine queries: try exact match OR contains OR wildcards
-    const allQueries = [exactQuery, containsQuery, ...wildcardQueries];
-    const query = `(${allQueries.join('^OR')})^LIMIT20`;
-    return query;
-  }
-
-  private async intelligentlyIndex(artifact: any): Promise<IndexedArtifact> {
-    // Intelligent indexing based on artifact type
-    const structure = await this.decomposeArtifact(artifact);
-    const context = await this.extractContext(artifact);
-    const relationships = await this.mapRelationships(artifact);
-    const claudeSummary = await this.createClaudeSummary(artifact);
-    const modificationPoints = await this.identifyModificationPoints(artifact);
-
-    return {
-      meta: {
-        sys_id: artifact.sys_id,
-        name: artifact.name || artifact.title,
-        title: artifact.title,
-        type: artifact.sys_class_name || 'unknown',
-        last_updated: artifact.sys_updated_on,
-      },
-      structure,
-      context,
-      relationships,
-      claudeSummary,
-      modificationPoints,
-    };
-  }
-
-  private async decomposeArtifact(artifact: any) {
-    // Decompose artifact based on type
-    if (artifact.sys_class_name === 'sp_widget') {
-      return this.decomposeWidget(artifact);
-    } else if (artifact.sys_class_name === 'sys_hub_flow') {
-      return this.decomposeFlow(artifact);
-    }
-    return { type: 'unknown', components: [] };
-  }
-
-  private async decomposeWidget(widget: any) {
-    return {
-      type: 'widget',
-      components: {
-        template: widget.template ? 'HTML template present' : 'No template',
-        css: widget.css ? 'Custom CSS present' : 'No custom CSS',
-        client_script: widget.client_script ? 'Client script present' : 'No client script',
-        server_script: widget.server_script ? 'Server script present' : 'No server script',
-        options: widget.option_schema ? JSON.parse(widget.option_schema) : [],
-      },
-    };
-  }
-
-  private async decomposeFlow(flow: any) {
-    return {
-      type: 'flow',
-      components: {
-        name: flow.name,
-        description: flow.description,
-        active: flow.active,
-        trigger: flow.trigger_conditions || 'Unknown trigger',
-        steps: 'Flow definition _analysis would go here',
-      },
-    };
-  }
-
-  private async extractContext(artifact: any) {
-    return {
-      usage: 'Context _analysis would determine usage patterns',
-      dependencies: 'Related artifacts would be identified here',
-      impact: 'Impact _analysis would be performed here',
-    };
-  }
-
-  private async mapRelationships(artifact: any) {
-    return {
-      relatedArtifacts: [],
-      dependencies: [],
-      usage: [],
-    };
-  }
-
-  private async createClaudeSummary(artifact: any): Promise<string> {
-    const name = artifact.name || artifact.title || 'Unknown';
-    const type = artifact.sys_class_name || 'artifact';
-    
-    return `${name} is a ${type} in ServiceNow. It can be modified using natural language instructions through Snow-Flow.`;
-  }
-
-  private async identifyModificationPoints(artifact: any) {
-    // Identify common modification points
-    return [
-      {
-        location: 'main_configuration',
-        type: 'modify_settings',
-        description: 'Main configuration can be modified',
-      },
-    ];
-  }
-
-  private async storeInMemory(artifact: IndexedArtifact) {
-    // Store in memory for future access
-    await fs.mkdir(this.memoryPath, { recursive: true });
-    const filePath = join(this.memoryPath, `${artifact.meta.sys_id}.json`);
-    await fs.writeFile(filePath, JSON.stringify(artifact, null, 2));
-  }
-
-  private async searchInMemory(intent: ParsedIntent) {
-    // Search in memory index
-    try {
-      const files = await fs.readdir(this.memoryPath);
-      const results = [];
-
-      for (const file of files) {
-        if (file.endsWith('.json')) {
-          try {
-            const content = await fs.readFile(join(this.memoryPath, file), 'utf8');
-            const artifact = JSON.parse(content);
-            
-            // Ensure artifact has basic structure
-            if (artifact && (artifact.meta || artifact.claudeSummary)) {
-              if (this.matchesIntent(artifact, intent)) {
-                results.push(artifact);
-              }
-            }
-          } catch (parseError) {
-            this.logger.warn(`Failed to parse memory file: ${file}`, parseError);
-            // Continue with next file
-          }
-        }
-      }
-
-      return results;
-    } catch (error) {
-      return [];
-    }
-  }
-
-  private matchesIntent(artifact: IndexedArtifact, intent: ParsedIntent): boolean {
-    const searchTerm = intent.identifier.toLowerCase();
-    
-    // Safe access to artifact properties with fallbacks
-    const artifactName = (artifact.meta?.name || artifact.meta?.title || '').toLowerCase();
-    const artifactSummary = (artifact.claudeSummary || '').toLowerCase();
-    
-    return artifactName.includes(searchTerm) || artifactSummary.includes(searchTerm);
-  }
-
-  private formatResults(results: any[]): string {
-    if (!results || results.length === 0) {
-      return '❌ No artifacts found matching your search criteria.\n\n🔍 **Debugging Info:**\n- ServiceNow connection appears to be working\n- Try broader search terms\n- Check if widgets exist in your ServiceNow instance\n- Use snow_deploy_widget to create new widgets first';
-    }
-
-    const formattedResults = results.map((result, index) => {
-      const name = result.name || result.title || result.display_name || result.sys_id || 'Unknown';
-      const type = result.sys_class_name || result.type || 'Unknown';
-      const artifactType = result.artifact_type || 'Unknown';
-      const tableName = result.table_name || 'Unknown';
-      const id = result.sys_id || 'Unknown';
-      const updated = result.sys_updated_on || result.last_updated || 'Unknown';
-      const active = result.active !== undefined ? (result.active ? 'Active' : 'Inactive') : 'Unknown';
-      const description = result.short_description || result.description || 'No description';
-      
-      return `${index + 1}. **${name}**\n   - Artifact Type: ${artifactType}\n   - Table: ${tableName}\n   - Class: ${type}\n   - ID: ${id}\n   - Status: ${active}\n   - Description: ${description}\n   - Updated: ${updated}`;
-    }).join('\n\n');
-
-    return `✅ Found ${results.length} artifact(s):\n\n${formattedResults}`;
-  }
-
-  private formatMemoryResults(results: IndexedArtifact[]): string {
-    return results.map((result, index) => 
-      `${index + 1}. **${result.meta.name}**\n   - Type: ${result.meta.type}\n   - Summary: ${result.claudeSummary}\n   - Modification Points: ${result.modificationPoints.length}`
-    ).join('\n\n');
-  }
-
-  private formatComprehensiveResults(results: any[]): string {
-    if (!results || results.length === 0) {
-      return '❌ No artifacts found across all ServiceNow tables.\n\n🔍 **Suggestions:**\n- Check spelling and try different terms\n- Include inactive records with include_inactive=true\n- Try broader search terms\n- The artifact might be in a scoped application';
-    }
-
-    // Group results by table type
-    const groupedResults = results.reduce((groups, result) => {
-      const tableDesc = result.table_description || result.table_name;
-      if (!groups[tableDesc]) {
-        groups[tableDesc] = [];
-      }
-      groups[tableDesc].push(result);
-      return groups;
-    }, {} as Record<string, any[]>);
-
-    let output = `✅ Found ${results.length} artifact(s) across ${Object.keys(groupedResults).length} table type(s):\n\n`;
-
-    for (const [tableDesc, tableResults] of Object.entries(groupedResults)) {
-      output += `## ${tableDesc}\n`;
-      
-      (tableResults as any[]).forEach((result: any, index: number) => {
-        const name = result.name || result.title || result.display_name || result.sys_id || 'Unknown';
-        const active = result.active !== undefined ? (result.active ? 'Active' : 'Inactive') : 'Unknown';
-        const description = result.short_description || result.description || 'No description';
-        const strategy = result.search_strategy || 'Unknown';
-        const collection = result.collection || result.table_name || 'Unknown';
-        
-        output += `${index + 1}. **${name}**\n`;
-        output += `   - Table: ${collection}\n`;
-        output += `   - Status: ${active}\n`;
-        output += `   - Description: ${description}\n`;
-        output += `   - Found via: ${strategy}\n`;
-        output += `   - Sys ID: ${result.sys_id}\n`;
-        
-        if (result.when) output += `   - When: ${result.when}\n`;
-        if (result.order) output += `   - Order: ${result.order}\n`;
-        if (result.condition) output += `   - Condition: ${result.condition}\n`;
-        
-        output += '\n';
-      });
-    }
-
-    return output;
-  }
-
-  private generateEditSuggestion(artifact: any): string {
-    if (!artifact) {
-      return '💡 Use snow_edit_artifact to modify ServiceNow artifacts with natural language.';
-    }
-    
-    const name = artifact.name || artifact.title || artifact.display_name || 'the artifact';
-    return `💡 To edit this artifact, use:\n\`snow-flow edit "modify ${name} to add [your requirements]"\``;
-  }
-
-  private async findTargetArtifact(intent: ParsedIntent) {
-    // Find the specific artifact to edit
-    const results = await this.searchServiceNow(intent);
-    if (results.length === 0) {
-      throw new Error('No matching artifact found');
-    }
-    
-    // Return the best match based on relevance scoring
-    return this.selectBestMatch(results, intent);
-  }
-
-  /**
-   * Select the best matching artifact based on relevance scoring
-   */
-  private selectBestMatch(results: any[], intent: ParsedIntent): any {
-    if (results.length === 1) {
-      return results[0];
-    }
-
-    // Score each result based on multiple factors
-    const scoredResults = results.map(result => {
-      let score = 0;
-
-      // Name/title similarity
-      const name = (result.name || result.title || '').toLowerCase();
-      const identifier = intent.identifier.toLowerCase();
-      
-      if (name === identifier) {
-        score += 100; // Exact match
-      } else if (name.includes(identifier) || identifier.includes(name)) {
-        score += 50; // Partial match
-      }
-
-      // Type match
-      if (result.type === intent.artifactType) {
-        score += 30;
-      }
-
-      // Recency (prefer more recently updated)
-      if (result.sys_updated_on) {
-        const daysSinceUpdate = (Date.now() - new Date(result.sys_updated_on).getTime()) / (1000 * 60 * 60 * 24);
-        score += Math.max(0, 10 - daysSinceUpdate); // More points for recent updates
-      }
-
-      // Active/non-test artifacts preferred
-      if (result.active !== false && !name.includes('test') && !name.includes('mock')) {
-        score += 10;
-      }
-
-      return { result, score };
-    });
-
-    // Sort by score and return the best match
-    scoredResults.sort((a, b) => b.score - a.score);
-    
-    this.logger.info('Selected best match', { 
-      selected: scoredResults[0].result.name,
-      score: scoredResults[0].score,
-      totalResults: results.length 
-    });
-    
-    return scoredResults[0].result;
-  }
-
-  /**
-   * Perform comprehensive flow _analysis and testing
-   */
-  private async performFlowAnalysis(sysId: string, flowType: string, flowData: any): Promise<any> {
-    const _analysis = {
-      structureValid: false,
-      triggerAnalysis: null,
-      recommendedTests: [],
-      performanceScore: 0,
-      securityIssues: [],
-      integrationPoints: []
-    };
-
-    try {
-      // Analyze flow structure
-      if (flowType === 'flow_designer' && flowData.latest_snapshot) {
-        const snapshot = JSON.parse(flowData.latest_snapshot);
-        const activities = snapshot.activities || snapshot.steps || [];
-        
-        _analysis.structureValid = activities.length > 0;
-        _analysis.performanceScore = this.calculateFlowPerformanceScore(activities);
-        _analysis.securityIssues = this.identifySecurityIssues(activities);
-        _analysis.integrationPoints = this.findIntegrationPoints(activities);
-      }
-
-      // Analyze trigger conditions
-      if (flowData.table && flowData.condition) {
-        _analysis.triggerAnalysis = {
-          table: flowData.table,
-          condition: flowData.condition,
-          active: flowData.active,
-          validTrigger: true
-        };
-        
-        // Recommend specific tests based on trigger
-        _analysis.recommendedTests = this.generateFlowTestRecommendations(flowData);
-      }
-
-      return _analysis;
-    } catch (error) {
-      this.logger.error('Flow _analysis failed', { sysId, error: error.message });
-      return {
-        ..._analysis,
-        error: error.message,
-        recommendation: 'Use snow_test_flow_with_mock() for safer testing'
-      };
-    }
-  }
-
-  private calculateFlowPerformanceScore(activities: any[]): number {
-    let score = 100;
-    
-    // Deduct points for potential performance issues
-    activities.forEach(activity => {
-      if (activity.type?.includes('wait') || activity.type?.includes('timer')) {
-        score -= 5; // Wait activities can slow flows
-      }
-      if (activity.script && activity.script.length > 1000) {
-        score -= 10; // Large scripts may impact performance
-      }
-      if (activity.type?.includes('loop')) {
-        score -= 15; // Loops can be performance bottlenecks
-      }
-    });
-
-    return Math.max(0, score);
-  }
-
-  private identifySecurityIssues(activities: any[]): string[] {
-    const issues = [];
-    
-    activities.forEach((activity, index) => {
-      if (activity.script) {
-        // Check for potential security issues
-        if (activity.script.includes('eval(')) {
-          issues.push(`Activity ${index + 1}: Uses eval() which is a security risk`);
-        }
-        if (activity.script.includes('gs.getUser().getUserID()') && !activity.script.includes('canRead')) {
-          issues.push(`Activity ${index + 1}: May have access control issues`);
-        }
-        if (activity.script.includes('XMLHttpRequest')) {
-          issues.push(`Activity ${index + 1}: External HTTP calls may pose security risks`);
-        }
-      }
-    });
-
-    return issues;
-  }
-
-  private findIntegrationPoints(activities: any[]): string[] {
-    const integrations = [];
-    
-    activities.forEach((activity, index) => {
-      if (activity.type?.includes('rest') || activity.type?.includes('soap')) {
-        integrations.push(`Activity ${index + 1}: External API integration (${activity.type})`);
-      }
-      if (activity.script && activity.script.includes('RESTMessage')) {
-        integrations.push(`Activity ${index + 1}: REST Message integration`);
-      }
-      if (activity.script && activity.script.includes('SOAPMessage')) {
-        integrations.push(`Activity ${index + 1}: SOAP Message integration`);
-      }
-    });
-
-    return integrations;
-  }
-
-  private generateFlowTestRecommendations(flowData: any): string[] {
-    const recommendations = [];
-    
-    if (flowData.table) {
-      recommendations.push(`Create test record in ${flowData.table} table`);
-    }
-    
-    if (flowData.condition) {
-      recommendations.push(`Test with records that match condition: ${flowData.condition}`);
-      recommendations.push(`Test with records that don't match condition (negative test)`);
-    }
-    
-    if (flowData.trigger_type === 'record_updated') {
-      recommendations.push('Test by updating existing records');
-    } else if (flowData.trigger_type === 'record_created') {
-      recommendations.push('Test by creating new records');
-    }
-
-    recommendations.push('Use snow_test_flow_with_mock() for isolated testing');
-    
-    return recommendations;
-  }
-
-  private async analyzeModification(intent: ParsedIntent, artifact: any) {
-    // Analyze what modification is needed
-    return {
-      type: 'configuration_change',
-      description: intent.modification || 'General modification',
-      target: artifact.sys_id,
-    };
-  }
-
-  private async applyModification(artifact: any, modification: any) {
-    // Apply the modification - this would be more sophisticated
-    return {
-      ...artifact,
-      modified: true,
-      modification_applied: modification,
-    };
-  }
-
-  private async deployArtifact(artifact: any) {
-    this.logger.info('Deploying modified artifact to ServiceNow', {
-      type: artifact.type,
-      sys_id: artifact.sys_id,
-      name: artifact.name
-    });
-
-    try {
-      // Determine the table name based on artifact type
-      let tableName: string;
-      let updateData: any = {};
-
-      switch (artifact.type) {
-        case 'widget':
-          tableName = 'sp_widget';
-          updateData = {
-            name: artifact.name,
-            title: artifact.title,
-            description: artifact.description,
-            template: artifact.template,
-            css: artifact.css,
-            client_script: artifact.client_script,
-            server_script: artifact.server_script,
-            option_schema: artifact.option_schema
-          };
-          break;
-
-        case 'flow':
-          tableName = 'sys_hub_flow';
-          updateData = {
-            name: artifact.name,
-            description: artifact.description,
-            active: artifact.active,
-            trigger_conditions: artifact.trigger_conditions,
-            flow_definition: typeof artifact.flow_definition === 'string' 
-              ? artifact.flow_definition 
-              : JSON.stringify(artifact.flow_definition)
-          };
-          break;
-
-        case 'subflow':
-          tableName = 'sys_hub_subflow';
-          updateData = {
-            name: artifact.name,
-            description: artifact.description,
-            inputs: typeof artifact.inputs === 'string' 
-              ? artifact.inputs 
-              : JSON.stringify(artifact.inputs || []),
-            outputs: typeof artifact.outputs === 'string' 
-              ? artifact.outputs 
-              : JSON.stringify(artifact.outputs || [])
-          };
-          break;
-
-        case 'business_rule':
-          tableName = 'sys_script';
-          updateData = {
-            name: artifact.name,
-            description: artifact.description,
-            script: artifact.script,
-            condition: artifact.condition,
-            when: artifact.when,
-            active: artifact.active
-          };
-          break;
-
-        case 'script_include':
-          tableName = 'sys_script_include';
-          updateData = {
-            name: artifact.name,
-            description: artifact.description,
-            script: artifact.script,
-            api_name: artifact.api_name,
-            active: artifact.active
-          };
-          break;
-
-        case 'client_script':
-          tableName = 'sys_script_client';
-          updateData = {
-            name: artifact.name,
-            description: artifact.description,
-            script: artifact.script,
-            table: artifact.table,
-            type: artifact.script_type,
-            condition: artifact.condition,
-            active: artifact.active
-          };
-          break;
-
-        case 'ui_policy':
-          tableName = 'sys_ui_policy';
-          updateData = {
-            short_description: artifact.name,
-            description: artifact.description,
-            conditions: artifact.condition,
-            on_load: artifact.on_load,
-            reverse_if_false: artifact.reverse_if_false,
-            active: artifact.active
-          };
-          break;
-
-        case 'application':
-          tableName = 'sys_app';
-          updateData = {
-            name: artifact.name,
-            short_description: artifact.short_description,
-            description: artifact.description,
-            version: artifact.version,
-            active: artifact.active
-          };
-          break;
-
-        default:
-          // Use the artifact's table property if available, or try to infer from type
-          tableName = artifact.table || artifact.type;
-          updateData = { ...artifact };
-          delete updateData.sys_id;
-          delete updateData.type;
-          delete updateData.table;
-          delete updateData.modified;
-          delete updateData.modification_applied;
-          break;
-      }
-
-      // Remove undefined/null values to avoid overwriting with empty data
-      Object.keys(updateData).forEach(key => {
-        if (updateData[key] === undefined || updateData[key] === null) {
-          delete updateData[key];
-        }
-      });
-
-      // Update the artifact in ServiceNow using the sys_id
-      const result = await this.client.put(`/api/now/table/${tableName}/${artifact.sys_id}`, updateData);
-
-      if (result.result) {
-        this.logger.info('Artifact successfully deployed to ServiceNow', {
-          type: artifact.type,
-          sys_id: artifact.sys_id,
-          name: artifact.name,
-          table: tableName
-        });
-
-        // Get instance info for URL generation
-        const instanceInfo = await this.client.getInstanceInfo();
-        const baseUrl = (instanceInfo.result && typeof instanceInfo.result === 'object' && 'instance_url' in instanceInfo.result 
-                         ? instanceInfo.result.instance_url 
-                         : null) || 
-                       `https://${process.env.SNOW_INSTANCE?.replace(/\/$/, '') || 'instance'}.service-now.com`;
-
-        return {
-          success: true,
-          message: 'Artifact deployed successfully',
-          data: {
-            sys_id: artifact.sys_id,
-            name: artifact.name,
-            type: artifact.type,
-            table: tableName,
-            url: `${baseUrl}/nav_to.do?uri=${tableName}.do?sys_id=${artifact.sys_id}`,
-            last_updated: new Date().toISOString()
-          }
-        };
-      } else {
-        throw new Error('No result returned from ServiceNow API');
-      }
-
-    } catch (error) {
-      this.logger.error('Failed to deploy artifact to ServiceNow', {
-        type: artifact.type,
-        sys_id: artifact.sys_id,
-        name: artifact.name,
-        error: error instanceof Error ? error.message : String(error)
-      });
-
-      return {
-        success: false,
-        message: `Failed to deploy artifact: ${error instanceof Error ? error.message : String(error)}`,
-        error: error instanceof Error ? error.message : String(error),
-        data: {
-          sys_id: artifact.sys_id,
-          name: artifact.name,
-          type: artifact.type,
-          deployment_attempt: new Date().toISOString()
-        }
-      };
-    }
-  }
-
-  private async updateMemoryIndex(artifact: any, modification: any) {
-    // Update the memory index with the changes
-    const indexed = await this.intelligentlyIndex(artifact);
-    await this.storeInMemory(indexed);
-  }
-
-  private getArtifactUrl(artifact: any): string {
-    // Generate ServiceNow URL for the artifact
-    return `sys_id=${artifact.sys_id}`;
-  }
-
-  private async getBySysId(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Getting artifact by sys_id', { sys_id: args.sys_id, table: args.table });
-
-      // Direct lookup by sys_id with retry logic for newly created records
-      let artifact = null;
-      let lastError = null;
-      
-      for (let attempt = 0; attempt < 3; attempt++) {
-        try {
-          // Note: client.getRecord returns the record directly, not a response object
-          artifact = await this.client.getRecord(args.table, args.sys_id);
-          if (artifact) {
-            break; // Success, exit retry loop
-          }
-        } catch (error) {
-          lastError = error;
-          this.logger.warn(`Attempt ${attempt + 1} failed for sys_id lookup:`, error);
-          
-          // If this is not the last attempt, wait before retrying
-          if (attempt < 2) {
-            await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1))); // Progressive delay
-          }
-        }
-      }
-      
-      // If direct lookup failed, try fallback search for newly created records
-      if (!artifact) {
-        this.logger.info('Direct lookup failed, trying fallback search...');
-        try {
-          const searchResult = await this.client.searchRecords(args.table, `sys_id=${args.sys_id}`, 1);
-          if (searchResult.success && searchResult.data.result.length > 0) {
-            artifact = searchResult.data.result[0];
-            this.logger.info('Found artifact via fallback search');
-          }
-        } catch (searchError) {
-          this.logger.warn('Fallback search also failed:', searchError);
-        }
-      }
-
-      if (!artifact) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `❌ Artifact not found with sys_id: ${args.sys_id} in table: ${args.table}\n\n🔍 **Troubleshooting:**\n- Verify the sys_id is correct\n- Check if the record was created in a different Update Set\n- Ensure you have read access to this table\n- For newly created records, try again in a few seconds\n\n**Last Error:** ${lastError?.message || 'Record not found'}`,
-            },
-          ],
-        };
-      }
-      
-      // Format the response with relevant fields
-      const formattedArtifact = {
-        sys_id: artifact.sys_id,
-        name: artifact.name || artifact.title || 'Unknown',
-        table: args.table,
-        ...artifact
-      };
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Found artifact by sys_id!\n\n🎯 **${formattedArtifact.name}**\n🆔 sys_id: ${args.sys_id}\n📊 Table: ${args.table}\n\n**All Fields:**\n${JSON.stringify(formattedArtifact, null, 2)}`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('Failed to get artifact by sys_id:', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Error getting artifact by sys_id: ${error}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async editBySysId(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Editing artifact by sys_id', { 
-        sys_id: args.sys_id, 
-        table: args.table, 
-        field: args.field,
-        value_length: args.value?.length || 0
-      });
-
-      // First, ensure we have an update set
-      const updateSetResult = await this.client.ensureUpdateSet();
-      if (!updateSetResult.success) {
-        this.logger.warn('No update set available, continuing without one');
-      }
-
-      // Build update data
-      const updateData = {
-        [args.field]: args.value
-      };
-
-      // Update the record directly by sys_id with validation
-      const response = await this.client.updateRecord(args.table, args.sys_id, updateData);
-      
-      if (!response.success) {
-        // Try to provide more specific error information
-        let errorDetails = response.error || 'Unknown error';
-        if (response.error?.includes('404') || response.error?.includes('not found')) {
-          errorDetails += `\n\n🔍 **Troubleshooting:**
-- Verify the sys_id exists in the specified table
-- Check if the record was recently created (may need a moment to be available)
-- Ensure you have write access to this record
-
-🔧 **Update Set Considerations:**
-- Check current Update Set: snow_smart_update_set with action="track"
-- Verify artifact is tracked: snow_get_by_sysid
-- Ensure Update Set is active for tracking changes
-
-💡 **Debug steps:**
-1. Check current Update Set status
-2. Verify artifact creation was tracked
-3. Use mock testing if record access fails`;
-        }
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `❌ Failed to update artifact: ${errorDetails}`,
-            },
-          ],
-        };
-      }
-
-      // Verify the update was applied successfully by reading back the field
-      let verificationResult = '';
-      try {
-        const updatedRecord = await this.client.getRecord(args.table, args.sys_id);
-        if (updatedRecord && updatedRecord[args.field] === args.value) {
-          verificationResult = '\n\n✅ **Verification:** Update confirmed - field value matches expected value';
-        } else {
-          verificationResult = '\n\n⚠️ **Verification:** Update may not have been applied correctly - consider checking manually';
-        }
-      } catch (verifyError) {
-        verificationResult = '\n\n⚠️ **Verification:** Could not verify update (record may still be processing)';
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Artifact successfully updated!\n\n🎯 **Updated Field:** ${args.field}\n🆔 sys_id: ${args.sys_id}\n📊 Table: ${args.table}\n📝 Value Length: ${args.value.length} characters\n\n✨ Update applied directly via sys_id - much more reliable than text search!${verificationResult}`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('Failed to edit artifact by sys_id:', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Error editing artifact by sys_id: ${error}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async syncDataConsistency(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('Starting data consistency sync', { operation: args.operation });
-      let syncResults = [];
-
-      switch (args.operation) {
-        case 'refresh_cache':
-          syncResults = await this.refreshCache(args.table);
-          break;
-        case 'validate_sysids':
-          syncResults = await this.validateSysIds(args.sys_id, args.table);
-          break;
-        case 'reindex_artifacts':
-          syncResults = await this.reindexArtifacts(args.table);
-          break;
-        case 'full_sync':
-          syncResults = await this.performFullSync();
-          break;
-        default:
-          throw new Error(`Unknown sync operation: ${args.operation}`);
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Data consistency sync completed!\n\n🔄 **Operation:** ${args.operation}\n\n📋 **Results:**\n${syncResults.map(r => `- ${r}`).join('\n')}\n\n✨ Data consistency issues have been resolved. Try your operations again.`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('Data consistency sync failed:', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Data consistency sync failed: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async refreshCache(table?: string): Promise<string[]> {
-    const results = [];
-    
-    if (table) {
-      // Clear any cached data for specific table
-      this.memoryIndex.clear(); // Clear in-memory cache
-      results.push(`Cache cleared for table: ${table}`);
-      results.push(`Note: This MCP uses real-time queries, no persistent cache to refresh`);
-    } else {
-      // Clear all in-memory data
-      this.memoryIndex.clear();
-      results.push('All internal caches cleared');
-      results.push(`Note: This MCP uses real-time ServiceNow queries for accuracy`);
-    }
-    
-    return results;
-  }
-
-  private async validateSysIds(sys_id?: string, table?: string): Promise<string[]> {
-    const results = [];
-    
-    if (sys_id && table) {
-      // Validate specific sys_id
-      try {
-        const record = await this.client.getRecord(table, sys_id);
-        if (record && record.success && record.data) {
-          results.push(`✅ sys_id ${sys_id} validated in table ${table}`);
-        } else {
-          results.push(`❌ sys_id ${sys_id} not found in table ${table}`);
-        }
-      } catch (error) {
-        results.push(`❌ sys_id ${sys_id} validation failed: ${error}`);
-      }
-    } else {
-      // Validate all known sys_ids in memory index
-      const memoryEntries = Array.from(this.memoryIndex.entries());
-      if (memoryEntries.length === 0) {
-        results.push('📝 No sys_ids found in memory index to validate');
-        return results;
-      }
-
-      results.push(`🔍 Validating ${memoryEntries.length} sys_ids from memory index...`);
-      let validCount = 0;
-      let invalidCount = 0;
-      
-      for (const [key, data] of memoryEntries) {
-        // Extract sys_id and table from memory data if available
-        try {
-          if (data.sys_id && data.table) {
-            const record = await this.client.getRecord(data.table, data.sys_id);
-            if (record && record.success && record.data) {
-              validCount++;
-            } else {
-              invalidCount++;
-              results.push(`❌ Invalid: ${data.sys_id} in ${data.table}`);
-            }
-          }
-        } catch (error) {
-          invalidCount++;
-          results.push(`❌ Validation error for ${key}: ${error}`);
-        }
-      }
-      
-      results.push(`✅ Validation complete: ${validCount} valid, ${invalidCount} invalid`);
-    }
-    
-    return results;
-  }
-
-  private async reindexArtifacts(table?: string): Promise<string[]> {
-    const results = [];
-    
-    if (table) {
-      // Re-index artifacts from specific table
-      try {
-        // Query the table to get current artifacts
-        const searchResults = await this.client.searchRecords(table, 'sys_idISNOTEMPTY', 100);
-        if (searchResults.success && searchResults.data) {
-          const artifacts = Array.isArray(searchResults.data) ? searchResults.data : [searchResults.data];
-          
-          // Clear existing entries for this table
-          for (const [key, data] of this.memoryIndex.entries()) {
-            if (data.table === table) {
-              this.memoryIndex.delete(key);
-            }
-          }
-          
-          // Re-index with fresh data
-          let indexedCount = 0;
-          for (const artifact of artifacts) {
-            if (artifact.sys_id && artifact.name) {
-              const indexKey = `${table}_${artifact.name.replace(/\s+/g, '_')}`;
-              this.memoryIndex.set(indexKey, {
-                sys_id: artifact.sys_id,
-                table: table,
-                name: artifact.name,
-                type: this.getArtifactTypeFromTable(table),
-                indexed_at: new Date().toISOString()
-              });
-              indexedCount++;
-            }
-          }
-          
-          results.push(`✅ Re-indexed ${indexedCount} artifacts from table: ${table}`);
-        } else {
-          results.push(`⚠️ Could not fetch artifacts from table: ${table}`);
-        }
-      } catch (error) {
-        results.push(`❌ Re-indexing failed for table ${table}: ${error}`);
-      }
-    } else {
-      // Re-index all known artifact tables
-      const artifactTables = ['sp_widget', 'wf_workflow', 'sys_script_include', 'sys_script'];
-      results.push(`🔍 Re-indexing artifacts from ${artifactTables.length} tables...`);
-      
-      let totalIndexed = 0;
-      for (const tableName of artifactTables) {
-        const tableResults = await this.reindexArtifacts(tableName);
-        totalIndexed += tableResults.filter(r => r.includes('✅')).length;
-      }
-      
-      results.push(`✅ Global re-indexing complete: ${totalIndexed} artifacts indexed`);
-      results.push(`💾 Memory index size: ${this.memoryIndex.size} entries`);
-    }
-    
-    return results;
-  }
-
-  private getArtifactTypeFromTable(table: string): string {
-    const tableTypeMap: { [key: string]: string } = {
-      'sp_widget': 'widget',
-      'wf_workflow': 'flow',
-      'sys_script_include': 'script',
-      'sys_script': 'business_rule',
-      'sys_db_object': 'table'
-    };
-    return tableTypeMap[table] || 'unknown';
-  }
-
-  private async performFullSync(): Promise<string[]> {
-    const results = [];
-    
-    // Combine all sync operations
-    const cacheResults = await this.refreshCache();
-    const validateResults = await this.validateSysIds();
-    const reindexResults = await this.reindexArtifacts();
-    
-    results.push(...cacheResults, ...validateResults, ...reindexResults);
-    results.push('Full synchronization completed');
-    
-    return results;
-  }
-
-  private async validateLiveConnection(args: any) {
-    const { test_level = 'basic', include_performance = false } = args;
-    
-    const startTime = Date.now();
-    const results: any = {
-      connection_status: 'unknown',
-      authentication_status: 'unknown',
-      permissions_status: 'unknown',
-      instance_info: {},
-      performance_metrics: {},
-      timestamp: new Date().toISOString()
-    };
-
-    try {
-      // Basic connection test
-      const systemInfo = await this.client.get('/api/now/table/sys_properties', { sysparm_limit: 1 });
-      const basicResponseTime = Date.now() - startTime;
-      
-      results.connection_status = 'success';
-      results.authentication_status = 'success';
-      results.instance_info = {
-        instance_url: systemInfo.request?.host || 'unknown',
-        version: systemInfo.result?.[0]?.sys_created_on ? 'accessible' : 'unknown'
-      };
-
-      if (include_performance) {
-        results.performance_metrics.basic_response_time_ms = basicResponseTime;
-      }
-
-      // Full test - read permissions
-      if (test_level === 'full' || test_level === 'permissions') {
-        const testStartTime = Date.now();
-        const tableTest = await this.client.get('/api/now/table/sys_user', { sysparm_limit: 1 });
-        const readResponseTime = Date.now() - testStartTime;
-        
-        results.permissions_status = tableTest.result ? 'read_success' : 'read_limited';
-        
-        if (include_performance) {
-          results.performance_metrics.read_test_response_time_ms = readResponseTime;
-        }
-      }
-
-      // Permissions test - write permissions  
-      if (test_level === 'permissions') {
-        try {
-          const writeStartTime = Date.now();
-          // Test write by creating a test record in a safe table
-          const testRecord = await this.client.post('/api/now/table/sys_update_set', {
-            name: `Test Connection ${Date.now()}`,
-            description: 'Temporary test record for connection validation - safe to delete'
-          });
-          
-          if (testRecord.result?.sys_id) {
-            // Immediately delete the test record
-            await this.client.delete(`/api/now/table/sys_update_set/${testRecord.result.sys_id}`);
-            results.permissions_status = 'write_success';
-          }
-          
-          const writeResponseTime = Date.now() - writeStartTime;
-          if (include_performance) {
-            results.performance_metrics.write_test_response_time_ms = writeResponseTime;
-          }
-        } catch (writeError) {
-          results.permissions_status = 'write_failed';
-          results.write_error = writeError instanceof Error ? writeError.message : 'Unknown write error';
-        }
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-
-    } catch (error) {
-      results.connection_status = 'failed';
-      results.error = error instanceof Error ? error.message : 'Unknown connection error';
-      
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Live Connection Validation Failed:\n${JSON.stringify(results, null, 2)}` 
-      }] };
-    }
-  }  private async batchDeploymentValidator(args: any) {
-    const { artifacts, validation_level = 'full', check_conflicts = true } = args;
-    
-    try {
-      const validationResults: any = {
-        validation_timestamp: new Date().toISOString(),
-        validation_level,
-        total_artifacts: artifacts.length,
-        validation_summary: {
-          passed: 0,
-          failed: 0,
-          warnings: 0
-        },
-        artifact_results: [],
-        conflicts_detected: [],
-        deployment_recommendations: []
-      };
-
-      // Validate each artifact
-      for (const artifact of artifacts) {
-        const artifactResult: any = {
-          sys_id: artifact.sys_id,
-          table: artifact.table,
-          type: artifact.type,
-          validation_status: 'pending',
-          issues: [],
-          recommendations: []
-        };
-
-        try {
-          // Fetch artifact details
-          const artifactData = await this.client.get(`/api/now/table/${artifact.table}/${artifact.sys_id}`);
-          
-          if (!artifactData.result) {
-            artifactResult.validation_status = 'failed';
-            artifactResult.issues.push('Artifact not found in ServiceNow');
-            validationResults.validation_summary.failed++;
-            continue;
-          }
-
-          artifactResult.artifact_data = artifactData.result;
-          
-          // Syntax validation
-          if (validation_level === 'syntax' || validation_level === 'full') {
-            const syntaxIssues = await this.validateArtifactSyntax(artifactData.result, artifact.type);
-            artifactResult.issues.push(...syntaxIssues);
-          }
-
-          // Dependency validation  
-          if (validation_level === 'dependencies' || validation_level === 'full') {
-            const dependencyIssues = await this.validateArtifactDependencies(artifactData.result, artifact.type);
-            artifactResult.issues.push(...dependencyIssues);
-          }
-
-          // Determine validation status
-          if (artifactResult.issues.length === 0) {
-            artifactResult.validation_status = 'passed';
-            validationResults.validation_summary.passed++;
-          } else if (artifactResult.issues.some((issue: any) => issue.severity === 'error')) {
-            artifactResult.validation_status = 'failed';
-            validationResults.validation_summary.failed++;
-          } else {
-            artifactResult.validation_status = 'warning';
-            validationResults.validation_summary.warnings++;
-          }
-
-        } catch (error) {
-          artifactResult.validation_status = 'failed';
-          artifactResult.issues.push({
-            severity: 'error',
-            message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`
-          });
-          validationResults.validation_summary.failed++;
-        }
-
-        validationResults.artifact_results.push(artifactResult);
-      }
-
-      // Check for conflicts between artifacts
-      if (check_conflicts) {
-        validationResults.conflicts_detected = await this.detectArtifactConflicts(artifacts);
-      }
-
-      // Generate deployment recommendations
-      validationResults.deployment_recommendations = this.generateDeploymentRecommendations(validationResults);
-
-      return { content: [{ type: 'text', text: JSON.stringify(validationResults, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Batch Deployment Validation Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  private async deploymentRollbackManager(args: any) {
-    const { update_set_id, action, rollback_reason, create_backup = true } = args;
-    
-    try {
-      const rollbackResults: any = {
-        update_set_id,
-        action,
-        timestamp: new Date().toISOString(),
-        status: 'pending',
-        backup_created: false,
-        rollback_steps: []
-      };
-
-      // Get update set details
-      const updateSet = await this.client.get(`/api/now/table/sys_update_set/${update_set_id}`);
-      
-      if (!updateSet.result) {
-        throw new Error(`Update Set not found: ${update_set_id}`);
-      }
-
-      rollbackResults.update_set_info = updateSet.result;
-
-      switch (action) {
-        case 'monitor':
-          rollbackResults.status = 'monitoring';
-          rollbackResults.monitoring_data = await this.monitorUpdateSetDeployment(update_set_id);
-          break;
-
-        case 'validate_rollback':
-          rollbackResults.status = 'validation_complete';
-          rollbackResults.rollback_feasibility = await this.validateRollbackFeasibility(update_set_id);
-          break;
-
-        case 'rollback':
-          if (!rollback_reason) {
-            throw new Error('Rollback reason is required for rollback action');
-          }
-
-          rollbackResults.rollback_reason = rollback_reason;
-
-          // Create backup if requested
-          if (create_backup) {
-            const backupResult = await this.createUpdateSetBackup(update_set_id);
-            rollbackResults.backup_created = true;
-            rollbackResults.backup_info = backupResult;
-          }
-
-          // Perform rollback
-          const rollbackSteps = await this.performUpdateSetRollback(update_set_id, rollback_reason);
-          rollbackResults.rollback_steps = rollbackSteps;
-          rollbackResults.status = 'rollback_complete';
-          break;
-
-        default:
-          throw new Error(`Unknown action: ${action}`);
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(rollbackResults, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Rollback Management Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  // Helper methods for the new functionality
-  private calculateFlowComplexity(steps: any[]): number {
-    // Simple complexity calculation based on step count and script presence
-    let complexity = steps.length;
-    const scriptSteps = steps.filter(step => step.script && step.script.trim().length > 0);
-    complexity += scriptSteps.length * 2; // Script steps are more complex
-    return Math.min(complexity, 100); // Cap at 100
-  }
-
-  private async validateArtifactSyntax(artifact: any, type: string): Promise<any[]> {
-    const issues = [];
-    
-    // Basic syntax validation based on artifact type
-    if (type === 'script' && artifact.script) {
-      // Check for basic JavaScript syntax issues
-      if (artifact.script.includes('gs.') && !artifact.script.includes('current')) {
-        issues.push({
-          severity: 'warning',
-          message: 'Script uses gs. methods but may be missing current record context'
-        });
-      }
-    }
-    
-    return issues;
-  }
-
-  private async validateArtifactDependencies(artifact: any, type: string): Promise<any[]> {
-    const issues = [];
-    
-    // Check for common dependency issues
-    if (artifact.sys_scope && artifact.sys_scope !== 'global') {
-      issues.push({
-        severity: 'info',
-        message: `Artifact is in scope: ${artifact.sys_scope}`
-      });
-    }
-    
-    return issues;
-  }
-
-  private async detectArtifactConflicts(artifacts: any[]): Promise<any[]> {
-    const conflicts = [];
-    
-    // Check for naming conflicts
-    const names = artifacts.map(a => a.name).filter(Boolean);
-    const duplicateNames = names.filter((name, index) => names.indexOf(name) !== index);
-    
-    for (const name of duplicateNames) {
-      conflicts.push({
-        type: 'naming_conflict',
-        message: `Multiple artifacts with name: ${name}`,
-        severity: 'warning'
-      });
-    }
-    
-    return conflicts;
-  }
-
-  private generateDeploymentRecommendations(validationResults: any): string[] {
-    const recommendations = [];
-    
-    if (validationResults.validation_summary.failed > 0) {
-      recommendations.push('Fix all failed validations before deployment');
-    }
-    
-    if (validationResults.validation_summary.warnings > 0) {
-      recommendations.push('Review and address warnings for optimal deployment');
-    }
-    
-    if (validationResults.conflicts_detected.length > 0) {
-      recommendations.push('Resolve conflicts between artifacts');
-    }
-    
-    recommendations.push('Create backup before deployment');
-    recommendations.push('Test in non-production environment first');
-    
-    return recommendations;
-  }
-
-  private async monitorUpdateSetDeployment(updateSetId: string): Promise<any> {
-    // Get update set status and related updates
-    const updates = await this.client.get('/api/now/table/sys_update_xml', {
-      sysparm_query: `update_set=${updateSetId}`,
-      sysparm_fields: 'name,type,state,sys_created_on'
-    });
-    
-    return {
-      total_updates: updates.result?.length || 0,
-      updates_by_state: this.groupUpdatesByState(updates.result || []),
-      last_activity: updates.result?.[0]?.sys_created_on || null
-    };
-  }
-
-  private async validateRollbackFeasibility(updateSetId: string): Promise<any> {
-    return {
-      feasible: true,
-      considerations: [
-        'Rollback will revert all changes in this update set',
-        'Dependent changes may be affected',
-        'Data created by flows/scripts may not be automatically removed'
-      ],
-      estimated_impact: 'medium'
-    };
-  }
-
-  private async createUpdateSetBackup(updateSetId: string): Promise<any> {
-    return {
-      backup_id: `backup_${updateSetId}_${Date.now()}`,
-      backup_timestamp: new Date().toISOString(),
-      status: 'created'
-    };
-  }
-
-  private async performUpdateSetRollback(updateSetId: string, reason: string): Promise<any[]> {
-    return [
-      'Identified changes in update set',
-      'Created rollback plan',
-      'Would execute rollback (simulation mode)',
-      `Rollback reason: ${reason}`
-    ];
-  }
-
-  private groupUpdatesByState(updates: any[]): any {
-    const grouped: any = {};
-    for (const update of updates) {
-      const state = update.state || 'unknown';
-      grouped[state] = (grouped[state] || 0) + 1;
-    }
-    return grouped;
-  }
-
-  private async escalatePermissions(args: any) {
-    const { required_roles, duration = 'session', reason, workflow_context } = args;
-    
-    try {
-      const escalationResults: any = {
-        requested_roles: required_roles,
-        duration,
-        reason,
-        workflow_context,
-        timestamp: new Date().toISOString(),
-        escalation_status: 'pending',
-        current_permissions: {},
-        required_actions: []
-      };
-
-      // Get current user info
-      const whoAmI = await this.client.get('/api/now/table/sys_user', {
-        sysparm_query: 'user_name=admin',  // Try admin user first
-        sysparm_fields: 'sys_id,user_name,name,email',
-        sysparm_limit: 1
-      });
-      
-      const currentUser = whoAmI.result?.[0];
-      if (!currentUser) {
-        return { content: [{ 
-          type: 'text', 
-          text: '❌ Could not identify current user. Please ensure you are logged in to ServiceNow.' 
-        }] };
-      }
-
-      // Get user roles
-      const userRoles = await this.client.get('/api/now/table/sys_user_has_role', {
-        sysparm_query: `user=${currentUser.sys_id}`,
-        sysparm_fields: 'role.name,role.description,inherited'
-      });
-
-      const currentRoles = userRoles.result?.map((r: any) => r.role?.name).filter(Boolean) || [];
-      const missingRoles = required_roles.filter((role: string) => !currentRoles.includes(role));
-
-      // Get instance URL
-      const instanceUrl = process.env.SNOW_INSTANCE ? 
-        `https://${process.env.SNOW_INSTANCE.replace(/\/$/, '')}.service-now.com` : 
-        'https://your-instance.service-now.com';
-
-      if (missingRoles.length === 0) {
-        return { content: [{ 
-          type: 'text', 
-          text: `✅ **Permission Check Passed**\n\nYou already have all required roles:\n${required_roles.map((r: string) => `- ✓ ${r}`).join('\n')}\n\nNo escalation needed!` 
-        }] };
-      }
-
-      // Build actionable response
-      let response = `🔐 **Permission Escalation Required**\n\n`;
-      response += `**Current User:** ${currentUser.name} (${currentUser.user_name})\n`;
-      response += `**Current Roles:** ${currentRoles.length > 0 ? currentRoles.join(', ') : 'None'}\n`;
-      response += `**Missing Roles:** ${missingRoles.join(', ')}\n`;
-      response += `**Reason:** ${reason}\n`;
-      response += `**Duration:** ${duration}\n\n`;
-      
-      response += `## 🎯 Required Actions:\n\n`;
-      
-      // Provide specific instructions for each missing role
-      for (const role of missingRoles) {
-        response += `### ${role} Role\n`;
-        
-        switch (role) {
-          case 'admin':
-            response += `The **admin** role provides:\n`;
-            response += `- Global scope access for creating widgets, flows, and applications\n`;
-            response += `- Ability to modify system tables and configurations\n`;
-            response += `- Access to all ServiceNow modules and features\n\n`;
-            response += `**How to obtain:**\n`;
-            response += `1. Contact your ServiceNow administrator\n`;
-            response += `2. Or if you have admin access: [Click here to manage user roles](${instanceUrl}/sys_user.do?sys_id=${currentUser.sys_id})\n`;
-            response += `3. In the "Roles" related list, click "Edit" and add "admin"\n\n`;
-            break;
-            
-          case 'app_creator':
-            response += `The **app_creator** role provides:\n`;
-            response += `- Create custom applications and scoped apps\n`;
-            response += `- Design application modules and menus\n`;
-            response += `- Manage application artifacts\n\n`;
-            response += `**How to obtain:**\n`;
-            response += `1. Request from ServiceNow administrator\n`;
-            response += `2. Or navigate to: [User Administration > Users](${instanceUrl}/sys_user_list.do)\n`;
-            response += `3. Find your user record and add "app_creator" role\n\n`;
-            break;
-            
-          case 'system_administrator':
-            response += `The **system_administrator** role provides:\n`;
-            response += `- Full system access and configuration\n`;
-            response += `- Advanced scripting and development capabilities\n`;
-            response += `- Access to all system properties and settings\n\n`;
-            response += `**How to obtain:**\n`;
-            response += `1. This is a highly privileged role - contact system admin\n`;
-            response += `2. Requires approval from ServiceNow instance owner\n\n`;
-            break;
-            
-          case 'global_admin':
-            response += `The **global_admin** role provides:\n`;
-            response += `- Cross-scope application access\n`;
-            response += `- Global artifact creation and management\n`;
-            response += `- Override scope restrictions\n\n`;
-            response += `**How to obtain:**\n`;
-            response += `1. Contact ServiceNow administrator\n`;
-            response += `2. May require business justification\n\n`;
-            break;
-            
-          default:
-            response += `The **${role}** role is required for this operation.\n\n`;
-            response += `**How to obtain:**\n`;
-            response += `1. Contact your ServiceNow administrator\n`;
-            response += `2. Request temporary access for: "${reason}"\n\n`;
-        }
-      }
-      
-      response += `## 💡 Alternative Solutions:\n\n`;
-      response += `1. **Use a development instance** where you have admin access\n`;
-      response += `2. **Request a personal developer instance** from [developer.servicenow.com](https://developer.servicenow.com)\n`;
-      response += `3. **Work with a team member** who has the required permissions\n`;
-      response += `4. **Use Update Sets** to package changes for deployment by an admin\n\n`;
-      
-      response += `## 📋 Template Request for Admin:\n\n`;
-      response += `\`\`\`\n`;
-      response += `Subject: Temporary Permission Request - ${reason}\n\n`;
-      response += `Hi Admin,\n\n`;
-      response += `I need temporary access to the following roles for development:\n`;
-      response += `- Roles needed: ${missingRoles.join(', ')}\n`;
-      response += `- Reason: ${reason}\n`;
-      response += `- Duration: ${duration}\n`;
-      response += `- Context: ${workflow_context || 'ServiceNow multi-agent development'}\n\n`;
-      response += `These permissions can be revoked after the ${duration === 'session' ? 'current session' : duration}.\n\n`;
-      response += `Thank you!\n`;
-      response += `\`\`\``;
-
-      return { content: [{ type: 'text', text: response }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Permission Escalation Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  private async analyzeRequirements(args: any) {
-    const { 
-      objective, 
-      auto_discover_dependencies = true, 
-      suggest_existing_components = true, 
-      create_dependency_map = true,
-      scope_preference = 'auto'
-    } = args;
-
-    try {
-      const _analysis: any = {
-        objective,
-        analysis_timestamp: new Date().toISOString(),
-        discovered_requirements: [],
-        existing_components: [],
-        dependency_map: {},
-        deployment_plan: {},
-        recommendations: []
-      };
-
-      // Parse objective to identify required components
-      const lowerObjective = objective.toLowerCase();
-      const requiredComponents = [];
-
-      // Intelligent component detection
-      if (lowerObjective.includes('provision') || lowerObjective.includes('user')) {
-        requiredComponents.push('user_management', 'provisioning_workflow');
-      }
-      if (lowerObjective.includes('iphone') || lowerObjective.includes('mobile') || lowerObjective.includes('device')) {
-        requiredComponents.push('mobile_device_management', 'device_catalog');
-      }
-      if (lowerObjective.includes('approval') || lowerObjective.includes('request')) {
-        requiredComponents.push('approval_workflow', 'request_management');
-      }
-      if (lowerObjective.includes('notification') || lowerObjective.includes('email')) {
-        requiredComponents.push('notification_system', 'email_templates');
-      }
-
-      _analysis.discovered_requirements = requiredComponents;
-
-      // Search for existing components if enabled
-      if (suggest_existing_components && requiredComponents.length > 0) {
-        for (const component of requiredComponents) {
-          try {
-            // Search flows
-            const flows = await this.client.get('/api/now/table/wf_workflow', {
-              sysparm_query: `name CONTAINS ${component} OR description CONTAINS ${component}`,
-              sysparm_limit: 5,
-              sysparm_fields: 'sys_id,name,description,active'
-            });
-
-            // Search widgets
-            const widgets = await this.client.get('/api/now/table/sp_widget', {
-              sysparm_query: `name CONTAINS ${component} OR title CONTAINS ${component}`,
-              sysparm_limit: 5,
-              sysparm_fields: 'sys_id,name,title,description'
-            });
-
-            // Search scripts
-            const scripts = await this.client.get('/api/now/table/sys_script_include', {
-              sysparm_query: `name CONTAINS ${component} OR description CONTAINS ${component}`,
-              sysparm_limit: 5,
-              sysparm_fields: 'sys_id,name,description,active'
-            });
-
-            if (flows.result?.length || widgets.result?.length || scripts.result?.length) {
-              _analysis.existing_components.push({
-                component_type: component,
-                flows: flows.result || [],
-                widgets: widgets.result || [],
-                scripts: scripts.result || [],
-                reuse_recommendation: 'Consider modifying existing components instead of creating new ones'
-              });
-            }
-          } catch (error) {
-            // Continue with other components if one fails
-          }
-        }
-      }
-
-      // Create dependency map if enabled
-      if (create_dependency_map) {
-        _analysis.dependency_map = {
-          primary_objective: objective,
-          required_artifacts: requiredComponents.map(comp => ({
-            name: comp,
-            type: this.inferArtifactType(comp),
-            dependencies: this.inferDependencies(comp),
-            priority: this.inferPriority(comp, objective)
-          })),
-          deployment_order: this.calculateDeploymentOrder(requiredComponents)
-        };
-      }
-
-      // Generate deployment plan
-      _analysis.deployment_plan = {
-        scope_recommendation: this.recommendScope(scope_preference, requiredComponents),
-        estimated_complexity: requiredComponents.length > 3 ? 'high' : requiredComponents.length > 1 ? 'medium' : 'low',
-        estimated_time: `${requiredComponents.length * 2} hours`,
-        required_permissions: this.inferRequiredPermissions(requiredComponents),
-        update_set_strategy: 'Create single Update Set for all related artifacts'
-      };
-
-      // Generate recommendations
-      _analysis.recommendations = [
-        `Development approach: ${_analysis.deployment_plan.estimated_complexity} complexity project`,
-        `Recommended scope: ${_analysis.deployment_plan.scope_recommendation}`,
-        `Consider reusing ${_analysis.existing_components.length} existing components found`,
-        'Create comprehensive test scenarios for all workflows',
-        'Implement proper error handling and notifications'
-      ];
-
-      if (_analysis.existing_components.length > 0) {
-        _analysis.recommendations.push('📋 Review existing components before creating new artifacts');
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(_analysis, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Requirements Analysis Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  private async smartUpdateSet(args: any) {
-    const { 
-      action, 
-      auto_track_related_artifacts = true, 
-      conflict_detection = true, 
-      dependency_validation = true, 
-      rollback_points = true,
-      update_set_name 
-    } = args;
-
-    try {
-      const results: any = {
-        action,
-        timestamp: new Date().toISOString(),
-        update_set_info: {},
-        tracked_artifacts: [],
-        conflicts_detected: [],
-        dependencies_validated: [],
-        rollback_points_created: []
-      };
-
-      switch (action) {
-        case 'create':
-          if (!update_set_name) {
-            throw new Error('update_set_name is required for create action');
-          }
-
-          const newUpdateSet = await this.client.post('/api/now/table/sys_update_set', {
-            name: update_set_name,
-            description: `Smart Update Set created by Snow-Flow at ${new Date().toISOString()}`,
-            state: 'build'
-          });
-
-          results.update_set_info = newUpdateSet.result;
-          results.status = 'created';
-          break;
-
-        case 'track':
-          // Get current update set
-          const currentUpdateSets = await this.client.get('/api/now/table/sys_update_set', {
-            sysparm_query: 'state=build',
-            sysparm_limit: 1,
-            sysparm_fields: 'sys_id,name,state'
-          });
-
-          if (currentUpdateSets.result?.[0]) {
-            const updateSet = currentUpdateSets.result[0];
-            
-            // Get all updates in this set
-            const updates = await this.client.get('/api/now/table/sys_update_xml', {
-              sysparm_query: `update_set=${updateSet.sys_id}`,
-              sysparm_fields: 'name,type,target_name,action'
-            });
-
-            results.update_set_info = updateSet;
-            results.tracked_artifacts = updates.result || [];
-          }
-          break;
-
-        case 'validate':
-          // Validate current update set
-          const validationResults = await this.validateUpdateSetDependencies();
-          results.dependencies_validated = validationResults;
-          break;
-
-        case 'conflict_check':
-          if (conflict_detection) {
-            const conflicts = await this.detectUpdateSetConflicts();
-            results.conflicts_detected = conflicts;
-          }
-          break;
-      }
-
-      // Add rollback points if enabled
-      if (rollback_points && results.update_set_info?.sys_id) {
-        results.rollback_points_created.push({
-          checkpoint_id: `checkpoint_${Date.now()}`,
-          update_set_id: results.update_set_info.sys_id,
-          created_at: new Date().toISOString(),
-          restoration_method: 'Use deployment_rollback_manager tool'
-        });
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Smart Update Set Management Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  private async orchestrateDevelopment(args: any) {
-    const { 
-      objective,
-      auto_spawn_agents = true,
-      shared_memory = true,
-      parallel_execution = true,
-      progress_monitoring = true,
-      auto_permissions = false,
-      smart_discovery = true,
-      live_testing = true,
-      auto_deploy = false
-    } = args;
-
-    try {
-      const orchestration: any = {
-        objective,
-        orchestration_id: `orchestration_${Date.now()}`,
-        started_at: new Date().toISOString(),
-        status: 'initializing',
-        mode: auto_deploy ? '🚀 DEPLOYMENT MODE (WILL CREATE REAL ARTIFACTS)' : '📋 PLANNING MODE (ANALYSIS ONLY)',
-        warning: auto_deploy ? '⚠️ WARNING: This will create REAL artifacts in ServiceNow!' : '✅ SAFE: This is planning only, no artifacts will be created',
-        agents_spawned: [],
-        shared_memory_enabled: shared_memory,
-        progress_monitor: {},
-        execution_plan: {},
-        actual_deployments: []
-      };
-
-      // Step 1: Analyze requirements
-      if (smart_discovery) {
-        const requirementAnalysis = await this.analyzeRequirements({
-          objective,
-          auto_discover_dependencies: true,
-          suggest_existing_components: true,
-          create_dependency_map: true
-        });
-        orchestration.requirement__analysis = requirementAnalysis;
-      }
-
-      // Step 2: Check permissions
-      if (auto_permissions) {
-        const permissionCheck = await this.escalatePermissions({
-          required_roles: ['admin', 'app_creator'],
-          duration: 'workflow',
-          reason: `Orchestrated development: ${objective}`
-        });
-        orchestration.permission_check = permissionCheck;
-      }
-
-      // Step 3: Create smart update set
-      const updateSetResult = await this.smartUpdateSet({
-        action: 'create',
-        update_set_name: `Orchestrated Development: ${objective.substring(0, 50)}`,
-        auto_track_related_artifacts: true,
-        conflict_detection: true,
-        rollback_points: true
-      });
-      orchestration.update_set = updateSetResult;
-
-      // Step 4: Generate execution plan
-      orchestration.execution_plan = {
-        phases: [
-          {
-            phase: 1,
-            name: 'Discovery & Analysis',
-            status: 'completed',
-            duration_estimate: '10 minutes'
-          },
-          {
-            phase: 2,
-            name: 'Artifact Development',
-            status: 'pending',
-            duration_estimate: '30-60 minutes',
-            parallel_execution_enabled: parallel_execution
-          },
-          {
-            phase: 3,
-            name: 'Testing & Validation',
-            status: 'pending',
-            duration_estimate: '15 minutes',
-            live_testing_enabled: live_testing
-          },
-          {
-            phase: 4,
-            name: 'Deployment',
-            status: 'pending',
-            duration_estimate: '10 minutes',
-            auto_deploy_enabled: auto_deploy
-          }
-        ],
-        total_estimated_time: '65-95 minutes'
-      };
-
-      // Step 5: Set up progress monitoring
-      if (progress_monitoring) {
-        orchestration.progress_monitor = {
-          enabled: true,
-          monitoring_interval: '30 seconds',
-          progress_tracking: 'real-time',
-          completion_notifications: true
-        };
-      }
-
-      // Step 6: Execute actual deployment if auto_deploy is enabled
-      if (auto_deploy) {
-        orchestration.status = 'executing_deployment';
-        
-        // Attempt to create real artifacts based on the objective
-        try {
-          const artifactAnalysis = await this.analyzeArtifactRequirements(objective);
-          
-          for (const artifact of artifactAnalysis.recommended_artifacts) {
-            try {
-              let deploymentResult: any;
-              
-              if (artifact.type === 'flow') {
-                // Use flow composer to create real flow
-                deploymentResult = await this.client.post('/api/now/table/sys_hub_flow', {
-                  name: artifact.name,
-                  description: artifact.description,
-                  active: true,
-                  type: 'flow'
-                });
-              } else if (artifact.type === 'widget') {
-                // Create real widget
-                deploymentResult = await this.client.post('/api/now/table/sp_widget', {
-                  name: artifact.name,
-                  title: artifact.name,
-                  description: artifact.description,
-                  template: artifact.template || '<div>{{data.message || "Widget created"}}</div>',
-                  css: artifact.css || '',
-                  client_script: artifact.client_script || '',
-                  server_script: artifact.server_script || '(function() { data.message = "Successfully deployed!"; })()',
-                  public: true,
-                  has_preview: true
-                });
-              }
-              
-              if (deploymentResult?.result) {
-                orchestration.actual_deployments.push({
-                  type: artifact.type,
-                  name: artifact.name,
-                  sys_id: deploymentResult.result.sys_id,
-                  status: 'deployed',
-                  url: `https://${process.env.SNOW_INSTANCE ? process.env.SNOW_INSTANCE.replace(/\/$/, '') : 'instance'}.service-now.com/nav_to.do?uri=${artifact.type === 'flow' ? 'sys_hub_flow' : 'sp_widget'}.do?sys_id=${deploymentResult.result.sys_id}`
-                });
-              }
-            } catch (deployError) {
-              orchestration.actual_deployments.push({
-                type: artifact.type,
-                name: artifact.name,
-                status: 'failed',
-                error: deployError instanceof Error ? deployError.message : String(deployError)
-              });
-            }
-          }
-          
-          orchestration.status = 'deployment_complete';
-          orchestration.completed_at = new Date().toISOString();
-          
-        } catch (error) {
-          orchestration.status = 'deployment_failed';
-          orchestration.deployment_error = error instanceof Error ? error.message : String(error);
-        }
-      } else {
-        orchestration.status = 'planning_complete';
-        orchestration.completed_at = new Date().toISOString();
-      }
-
-      // Set appropriate next steps based on mode
-      if (auto_deploy) {
-        if (orchestration.actual_deployments.length > 0) {
-          orchestration.next_steps = [
-            '✅ DEPLOYMENT COMPLETE: Real artifacts have been created in ServiceNow',
-            `📊 Created ${orchestration.actual_deployments.filter((d: any) => d.status === 'deployed').length} artifacts successfully`,
-            'Use snow_test_flow_execution or snow_widget_test to validate deployments',
-            'Check ServiceNow instance to verify artifacts are working correctly'
-          ];
-        } else {
-          orchestration.next_steps = [
-            '❌ DEPLOYMENT FAILED: No artifacts were created',
-            'Check deployment errors in actual_deployments array',
-            'Verify ServiceNow permissions and authentication',
-            'Consider running in planning mode first (auto_deploy: false)'
-          ];
-        }
-      } else {
-        orchestration.next_steps = [
-          '📋 PLANNING COMPLETE: This was _analysis only - no artifacts created',
-          '🚀 To deploy: Re-run with auto_deploy: true',
-          'Execute specific MCP tools manually:',
-          '  - snow_create_flow for flow creation',
-          '  - snow_deploy_widget for widget deployment',
-          '  - snow_resilient_deployment for batch deployment'
-        ];
-      }
-
-      return { content: [{ type: 'text', text: JSON.stringify(orchestration, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Development Orchestration Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-
-  private async resilientDeployment(args: any) {
-    const { 
-      artifacts,
-      retry_on_failure = true,
-      fallback_strategies = ['global_scope', 'manual_approval'],
-      checkpoint_restoration = true,
-      graceful_degradation = true,
-      max_retries = 3
-    } = args;
-
-    try {
-      const deployment: any = {
-        deployment_id: `deployment_${Date.now()}`,
-        started_at: new Date().toISOString(),
-        artifacts_count: artifacts.length,
-        status: 'initializing',
-        deployment_results: [],
-        checkpoints: [],
-        fallback_actions: [],
-        recovery_plan: {}
-      };
-
-      // Create checkpoint before deployment
-      if (checkpoint_restoration) {
-        const checkpoint = {
-          checkpoint_id: `pre_deployment_${Date.now()}`,
-          created_at: new Date().toISOString(),
-          artifacts_state: 'captured',
-          restoration_available: true
-        };
-        deployment.checkpoints.push(checkpoint);
-      }
-
-      // Process each artifact with resilient deployment
-      for (let i = 0; i < artifacts.length; i++) {
-        const artifact = artifacts[i];
-        const artifactResult: any = {
-          artifact_index: i + 1,
-          artifact_id: artifact.sys_id || artifact.id,
-          status: 'pending',
-          attempts: 0,
-          max_retries,
-          fallback_used: false
-        };
-
-        let deploymentSuccess = false;
-        let lastError = null;
-
-        // Retry logic
-        while (!deploymentSuccess && artifactResult.attempts < max_retries) {
-          artifactResult.attempts++;
-          
-          try {
-            // Attempt deployment (this would call actual deployment APIs)
-            const deployResult = await this.attemptArtifactDeployment(artifact);
-            if (deployResult.success) {
-              artifactResult.status = 'deployed';
-              artifactResult.deployment_details = deployResult.details;
-              deploymentSuccess = true;
-            }
-          } catch (error) {
-            lastError = error;
-            
-            if (retry_on_failure && artifactResult.attempts < max_retries) {
-              artifactResult.status = `retry_${artifactResult.attempts}`;
-              // Wait before retry
-              await new Promise(resolve => setTimeout(resolve, 2000 * artifactResult.attempts));
-            }
-          }
-        }
-
-        // Apply fallback strategies if deployment failed
-        if (!deploymentSuccess && fallback_strategies.length > 0) {
-          for (const strategy of fallback_strategies) {
-            try {
-              const fallbackResult = await this.applyFallbackStrategy(artifact, strategy);
-              if (fallbackResult.success) {
-                artifactResult.status = 'deployed_with_fallback';
-                artifactResult.fallback_used = strategy;
-                artifactResult.fallback_details = fallbackResult.details;
-                deploymentSuccess = true;
-                break;
-              }
-            } catch (fallbackError) {
-              // Continue to next fallback strategy
-            }
-          }
-        }
-
-        // Final status
-        if (!deploymentSuccess) {
-          artifactResult.status = 'failed';
-          artifactResult.error = lastError instanceof Error ? lastError.message : 'Deployment failed';
-          
-          if (graceful_degradation) {
-            artifactResult.degradation_applied = true;
-            artifactResult.degradation_note = 'Artifact marked for manual deployment';
-          }
-        }
-
-        deployment.deployment_results.push(artifactResult);
-      }
-
-      // Generate recovery plan
-      const failedArtifacts = deployment.deployment_results.filter((r: any) => r.status === 'failed');
-      if (failedArtifacts.length > 0) {
-        deployment.recovery_plan = {
-          failed_artifacts_count: failedArtifacts.length,
-          recovery_options: [
-            'Use checkpoint restoration to revert to pre-deployment state',
-            'Manual deployment of failed artifacts',
-            'Adjust permissions and retry deployment',
-            'Contact ServiceNow administrator for assistance'
-          ],
-          checkpoint_available: checkpoint_restoration
-        };
-      }
-
-      // Overall deployment status
-      const successCount = deployment.deployment_results.filter((r: any) => 
-        r.status === 'deployed' || r.status === 'deployed_with_fallback'
-      ).length;
-      
-      deployment.status = successCount === artifacts.length ? 'completed' : 
-                         successCount > 0 ? 'partially_completed' : 'failed';
-      deployment.success_rate = `${successCount}/${artifacts.length}`;
-
-      return { content: [{ type: 'text', text: JSON.stringify(deployment, null, 2) }] };
-
-    } catch (error) {
-      return { content: [{ 
-        type: 'text', 
-        text: `❌ Resilient Deployment Failed: ${error instanceof Error ? error.message : 'Unknown error'}` 
-      }] };
-    }
-  }
-  // Helper methods for the new functionality
-  private inferArtifactType(component: string): string {
-    if (component.includes('workflow') || component.includes('approval')) return 'flow';
-    if (component.includes('management') || component.includes('catalog')) return 'widget';
-    if (component.includes('notification') || component.includes('email')) return 'script';
-    return 'mixed';
-  }
-
-  private inferDependencies(component: string): string[] {
-    const deps = [];
-    if (component.includes('user')) deps.push('user_table');
-    if (component.includes('device')) deps.push('device_catalog', 'cmdb');
-    if (component.includes('approval')) deps.push('approval_engine', 'notification_system');
-    return deps;
-  }
-
-  private inferPriority(component: string, objective: string): 'high' | 'medium' | 'low' {
-    if (objective.toLowerCase().includes(component)) return 'high';
-    if (component.includes('workflow') || component.includes('approval')) return 'high';
-    return 'medium';
-  }
-
-  private calculateDeploymentOrder(components: string[]): string[] {
-    // Basic dependency-based ordering
-    const ordered = [...components];
-    return ordered.sort((a, b) => {
-      if (a.includes('table') || a.includes('catalog')) return -1;
-      if (b.includes('table') || b.includes('catalog')) return 1;
-      if (a.includes('script')) return -1;
-      if (b.includes('script')) return 1;
-      return 0;
-    });
-  }
-
-  private recommendScope(preference: string, components: string[]): string {
-    if (preference !== 'auto') return preference;
-    return components.length > 2 ? 'scoped' : 'global';
-  }
-
-  private inferRequiredPermissions(components: string[]): string[] {
-    const permissions = ['basic_user'];
-    if (components.some(c => c.includes('workflow') || c.includes('approval'))) {
-      permissions.push('workflow_designer');
-    }
-    if (components.some(c => c.includes('widget') || c.includes('portal'))) {
-      permissions.push('sp_portal_manager');
-    }
-    if (components.length > 3) {
-      permissions.push('admin');
-    }
-    return permissions;
-  }
-
-  private async validateUpdateSetDependencies(): Promise<any[]> {
-    // Simplified dependency validation
-    return [
-      { dependency: 'user_table', status: 'validated', details: 'Required table exists' },
-      { dependency: 'approval_engine', status: 'validated', details: 'Approval framework available' }
-    ];
-  }
-
-  private async detectUpdateSetConflicts(): Promise<any[]> {
-    // Simplified conflict detection
-    return [
-      { conflict_type: 'naming', severity: 'warning', description: 'Similar named artifacts found' }
-    ];
-  }
-
-  private async attemptArtifactDeployment(artifact: any): Promise<any> {
-    // 🔧 CRITICAL FIX: Replace mock implementation with real ServiceNow API calls
-    this.logger.info('Attempting real artifact deployment', { 
-      type: artifact.type, 
-      name: artifact.name || artifact.config?.name 
-    });
-
-    try {
-      let result;
-      
-      switch (artifact.type) {
-        case 'flow':
-          // Use the existing createFlow method
-          result = await this.client.createFlow({
-            name: artifact.config.name,
-            description: artifact.config.description,
-            type: artifact.config.flow_type || 'flow',
-            table: artifact.config.table,
-            trigger_type: artifact.config.trigger_type,
-            condition: artifact.config.condition,
-            active: artifact.config.active !== false,
-            flow_definition: artifact.config.flow_definition,
-            category: artifact.config.category || 'automation'
-          });
-          break;
-
-        case 'subflow':
-          // Use the existing createSubflow method
-          result = await this.client.createSubflow({
-            name: artifact.config.name,
-            description: artifact.config.description,
-            inputs: artifact.config.inputs || [],
-            outputs: artifact.config.outputs || [],
-            activities: artifact.config.activities || [],
-            category: artifact.config.category || 'custom'
-          });
-          break;
-
-        case 'widget':
-          // Use existing createRecord method for Service Portal widgets
-          result = await this.client.createRecord('sp_widget', {
-            name: artifact.config.name,
-            title: artifact.config.title || artifact.config.name,
-            description: artifact.config.description,
-            template: artifact.config.template || '<div>Widget content</div>',
-            css: artifact.config.css || '',
-            client_script: artifact.config.client_script || '',
-            server_script: artifact.config.server_script || '',
-            option_schema: artifact.config.option_schema || '[]',
-            category: artifact.config.category || 'custom'
-          });
-          break;
-
-        case 'business_rule':
-          // Create business rule
-          result = await this.client.createRecord('sys_script', {
-            name: artifact.config.name,
-            description: artifact.config.description,
-            table: artifact.config.table || 'incident',
-            when: artifact.config.when || 'before',
-            active: artifact.config.active !== false,
-            script: artifact.config.script || '// Business rule script',
-            condition: artifact.config.condition || '',
-            order: artifact.config.order || 100
-          });
-          break;
-
-        case 'script_include':
-          // Create script include
-          result = await this.client.createRecord('sys_script_include', {
-            name: artifact.config.name,
-            description: artifact.config.description,
-            script: artifact.config.script || 'var ' + artifact.config.name + ' = Class.create();',
-            api_name: artifact.config.api_name || artifact.config.name,
-            active: artifact.config.active !== false,
-            accessible_from: artifact.config.accessible_from || 'all'
-          });
-          break;
-
-        case 'table':
-          // Create custom table
-          result = await this.client.createRecord('sys_db_object', {
-            name: artifact.config.name,
-            label: artifact.config.label || artifact.config.name,
-            super_class: artifact.config.super_class || 'task',
-            create_module: artifact.config.create_module !== false,
-            create_menu: artifact.config.create_menu !== false
-          });
-          break;
-
-        case 'application':
-          // Create scoped application
-          result = await this.client.createRecord('sys_app', {
-            name: artifact.config.name,
-            description: artifact.config.description,
-            scope: artifact.config.scope || 'x_custom_' + artifact.config.name.toLowerCase().replace(/\s+/g, '_'),
-            version: artifact.config.version || '1.0.0',
-            vendor: artifact.config.vendor || 'Custom',
-            private: artifact.config.private !== false
-          });
-          break;
-
-        default:
-          throw new Error(`Unsupported artifact type: ${artifact.type}`);
-      }
-
-      if (result.success) {
-        this.logger.info('Artifact deployed successfully', {
-          type: artifact.type,
-          name: artifact.config.name,
-          sys_id: result.data?.sys_id
-        });
-
-        return {
-          success: true,
-          details: {
-            deployed_at: new Date().toISOString(),
-            sys_id: result.data?.sys_id,
-            url: result.data?.url,
-            type: artifact.type,
-            name: artifact.config.name,
-            deployment_method: 'real_api_call'
-          }
-        };
-      } else {
-        throw new Error(result.error || 'Unknown deployment error');
-      }
-
-    } catch (error) {
-      this.logger.error('Artifact deployment failed', {
-        type: artifact.type,
-        name: artifact.config?.name,
-        error: error instanceof Error ? error.message : String(error)
-      });
-
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        details: {
-          attempted_at: new Date().toISOString(),
-          type: artifact.type,
-          name: artifact.config?.name,
-          deployment_method: 'real_api_call'
-        }
-      };
-    }
-  }
-
-  private async applyFallbackStrategy(artifact: any, strategy: string): Promise<any> {
-    // 🔧 CRITICAL FIX: Replace mock fallback with real implementation strategies
-    this.logger.info('Applying fallback strategy', { 
-      strategy, 
-      artifactType: artifact.type,
-      artifactName: artifact.config?.name 
-    });
-
-    try {
-      let result;
-
-      switch (strategy) {
-        case 'global_scope':
-          // Try deploying to global scope with enhanced permissions
-          artifact.config.scope = 'global';
-          artifact.config.sys_domain = 'global';
-          result = await this.attemptArtifactDeployment(artifact);
-          break;
-
-        case 'simplified_version':
-          // Create a simplified version of the artifact
-          const simplifiedArtifact = { ...artifact };
-          if (artifact.type === 'flow') {
-            // Simplify flow definition - remove complex activities
-            const flowDef = typeof artifact.config.flow_definition === 'string' 
-              ? JSON.parse(artifact.config.flow_definition) 
-              : artifact.config.flow_definition;
-            
-            if (flowDef.activities) {
-              flowDef.activities = flowDef.activities.filter((activity: any) => 
-                ['approval', 'notification', 'script'].includes(activity.type)
-              );
-            }
-            
-            simplifiedArtifact.config.flow_definition = JSON.stringify(flowDef);
-            simplifiedArtifact.config.name += '_simplified';
-          } else if (artifact.type === 'widget') {
-            // Generate simplified but functional widget template
-            const widgetInstruction = artifact.config.description || artifact.config.name || 'simplified widget';
-            const generatedWidget = widgetTemplateGenerator.generateWidget({
-              title: artifact.config.title || artifact.config.name,
-              instruction: widgetInstruction,
-              type: 'info', // Use info type for simplified widgets
-              theme: 'minimal',
-              responsive: true
-            });
-            
-            simplifiedArtifact.config.template = generatedWidget.template;
-            simplifiedArtifact.config.css = generatedWidget.css;
-            simplifiedArtifact.config.client_script = generatedWidget.clientScript;
-            simplifiedArtifact.config.server_script = generatedWidget.serverScript;
-            simplifiedArtifact.config.option_schema = generatedWidget.optionSchema;
-            simplifiedArtifact.config.name += '_simplified';
-          }
-          
-          result = await this.attemptArtifactDeployment(simplifiedArtifact);
-          break;
-
-        case 'business_rule_fallback':
-          // Convert flow to business rule as fallback
-          if (artifact.type === 'flow') {
-            const businessRuleConfig = {
-              name: `BR_${artifact.config.name}`,
-              description: `Business Rule fallback for flow: ${artifact.config.name}`,
-              table: artifact.config.table || 'incident',
-              when: 'after',
-              script: `
-// Auto-generated Business Rule fallback for Flow: ${artifact.config.name}
-// Original flow description: ${artifact.config.description || 'No description'}
-
-try {
-  // Basic automation logic
-  if (current.isNewRecord()) {
-    gs.info('Record created, executing flow logic: ${artifact.config.name}');
-    
-    // Add your custom logic here based on original flow
-    ${this.generateBusinessRuleScript(artifact.config)}
-  }
-} catch (e) {
-  gs.error('Business Rule fallback error: ' + e.message);
-}
-              `.trim(),
-              active: true,
-              condition: artifact.config.condition || ''
-            };
-
-            result = await this.client.createRecord('sys_script', businessRuleConfig);
-          } else {
-            throw new Error('Business rule fallback only available for flows');
-          }
-          break;
-
-        case 'minimal_deployment':
-          // Deploy with absolute minimum configuration
-          const minimalArtifact = { ...artifact };
-          
-          // Strip all non-essential properties
-          const essentialFields = ['name', 'description', 'active'];
-          const cleanedConfig: any = {};
-          
-          essentialFields.forEach(field => {
-            if (artifact.config[field] !== undefined) {
-              cleanedConfig[field] = artifact.config[field];
-            }
-          });
-
-          // Add type-specific essentials
-          if (artifact.type === 'flow') {
-            cleanedConfig.type = 'subflow'; // Subflows are simpler
-            cleanedConfig.category = 'custom';
-          } else if (artifact.type === 'widget') {
-            // Generate minimal but functional widget template
-            const widgetInstruction = artifact.config.description || artifact.config.name || 'minimal widget';
-            const generatedWidget = widgetTemplateGenerator.generateWidget({
-              title: artifact.config.title || artifact.config.name,
-              instruction: widgetInstruction,
-              type: 'info', // Use info type for minimal widgets
-              theme: 'minimal',
-              responsive: true
-            });
-            
-            cleanedConfig.template = generatedWidget.template;
-            cleanedConfig.css = generatedWidget.css;
-            cleanedConfig.client_script = generatedWidget.clientScript;
-            cleanedConfig.server_script = generatedWidget.serverScript;
-            cleanedConfig.option_schema = generatedWidget.optionSchema;
-            cleanedConfig.title = artifact.config.title || artifact.config.name;
-          }
-
-          minimalArtifact.config = cleanedConfig;
-          minimalArtifact.config.name += '_minimal';
-          
-          result = await this.attemptArtifactDeployment(minimalArtifact);
-          break;
-
-        case 'delayed_retry':
-          // Wait and retry original deployment
-          await new Promise(resolve => setTimeout(resolve, 2000));
-          result = await this.attemptArtifactDeployment(artifact);
-          break;
-
-        default:
-          throw new Error(`Unknown fallback strategy: ${strategy}`);
-      }
-
-      if (result.success) {
-        this.logger.info('Fallback strategy successful', {
-          strategy,
-          artifactType: artifact.type,
-          artifactName: artifact.config?.name,
-          deployedSysId: result.details?.sys_id
-        });
-
-        return {
-          success: true,
-          details: {
-            fallback_strategy: strategy,
-            applied_at: new Date().toISOString(),
-            original_artifact: artifact.config?.name,
-            deployed_artifact: result.details?.name || artifact.config?.name,
-            sys_id: result.details?.sys_id,
-            deployment_method: 'fallback_strategy'
-          }
-        };
-      } else {
-        throw new Error(result.error || `Fallback strategy ${strategy} failed`);
-      }
-
-    } catch (error) {
-      this.logger.error('Fallback strategy failed', {
-        strategy,
-        artifactType: artifact.type,
-        error: error instanceof Error ? error.message : String(error)
-      });
-
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        details: {
-          fallback_strategy: strategy,
-          attempted_at: new Date().toISOString(),
-          original_artifact: artifact.config?.name,
-          deployment_method: 'fallback_strategy'
-        }
-      };
-    }
-  }
-
-  private generateBusinessRuleScript(flowConfig: any): string {
-    // Generate basic business rule script based on flow configuration
-    let script = '// Generated business rule logic\n';
-    
-    if (flowConfig.trigger_type === 'record_created') {
-      script += 'gs.info("Record created trigger activated");\n';
-    }
-    
-    if (flowConfig.condition) {
-      script += `// Original condition: ${flowConfig.condition}\n`;
-    }
-    
-    script += 'gs.info("Business rule executed successfully");\n';
-    
-    return script;
-  }
-
-  private async generateFlowTestData(flow: any): Promise<any> {
-    return {
-      test_record: { state: 'new', priority: 'medium' },
-      user_context: { role: 'test_user', department: 'IT' },
-      variables: { test_mode: true }
-    };
-  }
-
-  private async runFunctionalTests(flowId: string, testData: any): Promise<any[]> {
-    return [
-      { test_name: 'Basic Flow Execution', status: 'passed', duration: '2.5s' },
-      { test_name: 'Variable Passing', status: 'passed', duration: '1.2s' }
-    ];
-  }
-
-  private async runEdgeCaseTests(flowId: string): Promise<any[]> {
-    return [
-      { test_name: 'Null Input Handling', status: 'passed', duration: '1.8s' },
-      { test_name: 'Invalid State Transition', status: 'failed', error: 'State validation missing' }
-    ];
-  }
-
-  private async runPerformanceTests(flowId: string): Promise<any[]> {
-    return [
-      { test_name: 'Execution Time', status: 'passed', duration: '3.2s', threshold: '5s' },
-      { test_name: 'Memory Usage', status: 'passed', memory: '12MB', threshold: '50MB' }
-    ];
-  }
-
-  private async runIntegrationTests(flowId: string): Promise<any[]> {
-    return [
-      { test_name: 'External API Calls', status: 'passed', duration: '4.1s' },
-      { test_name: 'Database Operations', status: 'passed', duration: '2.8s' }
-    ];
-  }
-
-  private async runCustomTestScenario(flowId: string, scenario: any): Promise<any> {
-    return {
-      scenario_name: scenario.name || 'Custom Scenario',
-      status: 'passed',
-      duration: '2.1s',
-      details: 'Custom scenario executed successfully'
-    };
-  }
-
-  private async analyzeArtifactRequirements(objective: string): Promise<any> {
-    const artifactAnalysis = {
-      objective,
-      recommended_artifacts: []
-    };
-
-    const lowerObjective = objective.toLowerCase();
-    
-    // Simple keyword-based _analysis for artifact type detection
-    if (lowerObjective.includes('flow') || lowerObjective.includes('workflow') || lowerObjective.includes('automation')) {
-      artifactAnalysis.recommended_artifacts.push({
-        type: 'flow',
-        name: `Flow for ${objective.substring(0, 50)}`,
-        description: `Automated flow created for: ${objective}`,
-        priority: 'high'
-      });
-    }
-    
-    if (lowerObjective.includes('widget') || lowerObjective.includes('dashboard') || lowerObjective.includes('display')) {
-      artifactAnalysis.recommended_artifacts.push({
-        type: 'widget',
-        name: `Widget for ${objective.substring(0, 50)}`,
-        description: `Service Portal widget for: ${objective}`,
-        template: '<div class="panel panel-default"><div class="panel-body">{{data.message || "Widget deployed successfully"}}<br><small>Created for: ' + objective + '</small></div></div>',
-        css: '.panel { margin: 10px; }',
-        client_script: 'function() { console.log("Widget loaded"); }',
-        server_script: '(function() { data.message = "Successfully deployed for: ' + objective.replace(/"/g, '\\"') + '"; })()',
-        priority: 'medium'
-      });
-    }
-    
-    if (lowerObjective.includes('script') || lowerObjective.includes('function') || lowerObjective.includes('utility')) {
-      artifactAnalysis.recommended_artifacts.push({
-        type: 'script_include',
-        name: `Script for ${objective.substring(0, 50)}`,
-        description: `Script include for: ${objective}`,
-        script: `// Script created for: ${objective}\nvar ScriptUtility = Class.create();\nScriptUtility.prototype = {\n  initialize: function() {},\n  execute: function() {\n    gs.info('Script executed for: ${objective}');\n    return true;\n  },\n  type: 'ScriptUtility'\n};\n`,
-        priority: 'low'
-      });
-    }
-    
-    // If no specific artifacts detected, create a default flow
-    if (artifactAnalysis.recommended_artifacts.length === 0) {
-      artifactAnalysis.recommended_artifacts.push({
-        type: 'flow',
-        name: `General Flow for ${objective.substring(0, 40)}`,
-        description: `General purpose flow for: ${objective}`,
-        priority: 'medium'
-      });
-    }
-    
-    return artifactAnalysis;
-  }
-
-  private generateTestRecommendations(testResults: any): string[] {
-    const recommendations = [];
-    
-    if (testResults.test_summary.success_rate < 90) {
-      recommendations.push('⚠️ Consider addressing failed tests before deployment');
-    }
-    
-    recommendations.push('✅ Implement monitoring for production flow execution');
-    recommendations.push('📊 Set up performance baselines for future comparisons');
-    
-    return recommendations;
-  }
-
-  private async findFlowByNameOrSysId(identifier: string): Promise<any> {
-    try {
-      // First try as sys_id in sys_hub_flow
-      const result = await this.client.get(`/api/now/table/sys_hub_flow/${identifier}`);
-      if (result.result) {
-        result.result.sys_class_name = 'sys_hub_flow';
-        return result.result;
-      }
-    } catch (error) {
-      // Not a sys_id in sys_hub_flow
-    }
-
-    try {
-      // Try as sys_id in wf_workflow
-      const result = await this.client.get(`/api/now/table/wf_workflow/${identifier}`);
-      if (result.result) {
-        result.result.sys_class_name = 'wf_workflow';
-        return result.result;
-      }
-    } catch (error) {
-      // Not a sys_id in wf_workflow
-    }
-
-    // Search by name in both tables
-    try {
-      // Search in sys_hub_flow
-      const modernFlows = await this.client.get('/api/now/table/sys_hub_flow', {
-        sysparm_query: `name=${identifier}^ORnameSTARTSWITH${identifier}`,
-        sysparm_limit: 1,
-        sysparm_fields: 'name,description,active,type,status,sys_id,latest_snapshot'
-      });
-      
-      if (modernFlows.result && modernFlows.result.length > 0) {
-        modernFlows.result[0].sys_class_name = 'sys_hub_flow';
-        return modernFlows.result[0];
-      }
-    } catch (error) {
-      // Continue to legacy search
-    }
-
-    try {
-      // Search in wf_workflow
-      const legacyFlows = await this.client.get('/api/now/table/wf_workflow', {
-        sysparm_query: `name=${identifier}^ORnameSTARTSWITH${identifier}`,
-        sysparm_limit: 1,
-        sysparm_fields: 'name,description,active,table,sys_id'
-      });
-      
-      if (legacyFlows.result && legacyFlows.result.length > 0) {
-        legacyFlows.result[0].sys_class_name = 'wf_workflow';
-        return legacyFlows.result[0];
-      }
-    } catch (error) {
-      // No results found
-    }
-
-    return null;
-  }
-
-  /**
-   * 🔴 SNOW-002 FIX: Verify artifact is searchable after creation
-   * This method is called by other MCP servers after creating artifacts
-   */
-  private async generateDocumentation(args: any) {
-    try {
-      this.logger.info('📚 Generating autonomous documentation', args);
-      
-      const result = await this.documentationSystem.generateDocumentation({
-        scope: args.scope || 'full',
-        components: args.components,
-        format: args.format || 'markdown',
-        includePrivate: false,
-        includeDiagrams: args.include_diagrams !== false,
-        includeExamples: args.include_examples !== false,
-      });
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Documentation generated successfully!
-
-📊 Summary:
-- Quality Score: ${result.profile.analytics.qualityScore}/100
-- Completeness: ${result.profile.analytics.completeness}%
-- Sections: ${result.profile.sections.length}
-- Diagrams: ${result.profile.diagrams.length}
-- APIs Documented: ${result.profile.apiDocumentation.length}
-
-📁 Output: ${result.outputPath || 'Generated in memory'}
-
-⚠️ Warnings: ${result.warnings.length > 0 ? result.warnings.join('\n') : 'None'}
-
-💡 Suggestions:
-${result.suggestions.map(s => `- ${s}`).join('\n')}`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('❌ Documentation generation failed', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Documentation generation failed: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async getDocumentationSuggestions(args: any) {
-    try {
-      this.logger.info('💡 Getting documentation suggestions', args);
-      
-      // Get latest profile if not specified
-      let profileId = args.profile_id;
-      if (!profileId) {
-        const profiles = this.documentationSystem.getDocumentationProfiles();
-        if (profiles.length === 0) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: '⚠️ No documentation profiles found. Please generate documentation first using snow_generate_documentation.',
-              },
-            ],
-          };
-        }
-        profileId = profiles[0].id;
-      }
-      
-      const suggestions = await this.documentationSystem.suggestDocumentationImprovements(profileId);
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `📊 Documentation Improvement Suggestions
-
-Priority: ${suggestions.priority.toUpperCase()}
-Estimated Time: ${suggestions.estimatedTime} minutes
-
-📋 Suggestions:
-${suggestions.suggestions.map((s, i) => `
-${i + 1}. ${s.title} (${s.impact} impact, ${s.effort} effort)
-   ${s.description}
-   Components: ${s.components.join(', ')}
-   ${s.automated ? '✅ Can be automated' : '⚠️ Manual intervention required'}`).join('\n')}`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('❌ Failed to get documentation suggestions', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Failed to get suggestions: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async startContinuousDocumentation(args: any) {
-    try {
-      this.logger.info('🔄 Starting continuous documentation', args);
-      
-      await this.documentationSystem.startContinuousDocumentation({
-        interval: args.interval,
-        scope: args.scope,
-        autoCommit: args.auto_commit || false,
-      });
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Continuous documentation started!
-
-🔄 Configuration:
-- Update Interval: ${args.interval ? `${args.interval / 1000 / 60} minutes` : '60 minutes (default)'}
-- Monitored Components: ${args.scope ? args.scope.join(', ') : 'All components'}
-- Auto-commit: ${args.auto_commit ? 'Enabled' : 'Disabled'}
-
-📝 The system will now automatically:
-- Monitor for changes
-- Update documentation incrementally
-- Generate diagrams for new components
-- Track API changes
-- Maintain change logs
-
-Use snow_generate_documentation to manually trigger a full update at any time.`,
-          },
-        ],
-      };
-    } catch (error) {
-      this.logger.error('❌ Failed to start continuous documentation', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Failed to start continuous documentation: ${error instanceof Error ? error.message : String(error)}`,
-          },
-        ],
-      };
-    }
-  }
-
-  private async verifyArtifactSearchable(args: any) {
-    // Check authentication first
-    const authResult = await mcpAuth.ensureAuthenticated();
-    if (!authResult.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: authResult.error || '❌ Not authenticated with ServiceNow.\n\nPlease run: snow-flow auth login\n\nOr configure your .env file with ServiceNow OAuth credentials.',
-          },
-        ],
-      };
-    }
-
-    try {
-      this.logger.info('🔴 SNOW-002 FIX: Verifying artifact searchability', { 
-        name: args.artifact_name, 
-        type: args.artifact_type,
-        sys_id: args.expected_sys_id 
-      });
-
-      const maxWaitTime = args.max_wait_time || 30; // seconds
-      const startTime = Date.now();
-      
-      // Use the specialized search method for newly created artifacts
-      const results = await this.searchForRecentlyCreatedArtifact(
-        args.artifact_name, 
-        args.artifact_type, 
-        args.expected_sys_id
-      );
-      
-      const elapsedTime = Math.round((Date.now() - startTime) / 1000);
-      
-      if (results && results.length > 0) {
-        const artifact = results[0];
-        
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `✅ SNOW-002 RESOLVED: Artifact is now searchable!
-
-🎯 **Verification Results:**
-- **Artifact**: ${args.artifact_name}
-- **Type**: ${args.artifact_type}
-- **Sys ID**: ${artifact.sys_id}
-- **Search Time**: ${elapsedTime} seconds
-- **Status**: ✅ Searchable and indexed
-
-🔍 **Search Verification:**
-- Found via: ${artifact.search_fallback ? 'Fallback search' : 'Standard search'}
-- Table: ${artifact.table_name || 'Auto-detected'}
-- Results: ${results.length} matching record(s)
-
-💡 **SNOW-002 Fix Status**: Search system timing issues resolved - artifact indexing delay successfully handled with retry logic.
-
-The artifact is now fully searchable and indexed in ServiceNow! 🎉`,
-            },
-          ],
-        };
-      } else {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `❌ SNOW-002 UNRESOLVED: Artifact still not searchable
-
-🔍 **Verification Results:**
-- **Artifact**: ${args.artifact_name}
-- **Type**: ${args.artifact_type}
-- **Search Time**: ${elapsedTime} seconds (timeout: ${maxWaitTime}s)
-- **Status**: ❌ Not found in search indexes
-
-🚨 **Possible Issues:**
-1. ServiceNow search indexes may need more time to update
-2. Artifact may have been created with different name/scope
-3. ServiceNow instance may have search indexing issues
-4. Artifact may not be active or may be in wrong scope
-
-💡 **Recommendations:**
-1. Wait a few more minutes and try again
-2. Check artifact directly in ServiceNow UI
-3. Use snow_get_by_sysid if you have the sys_id
-4. Contact ServiceNow administrator if issue persists
-
-**Manual Verification Steps:**
-1. Log into ServiceNow
-2. Navigate to the appropriate module
-3. Search for "${args.artifact_name}" manually
-4. Check if artifact exists but under different name`,
-            },
-          ],
-        };
-      }
-    } catch (error) {
-      this.logger.error('🔴 SNOW-002: Artifact verification failed:', error);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ SNOW-002: Artifact verification failed
-
-**Error**: ${error instanceof Error ? error.message : String(error)}
-
-This may indicate a deeper ServiceNow connectivity issue or authentication problem.
-Please check your ServiceNow connection and try again.`,
-          },
-        ],
-      };
-    }
-  }
-
-  async run() {
-    try {
-      // Initialize systems first
-      await this.initializeSystems();
-      
-      // Connect transport
-      const transport = new StdioServerTransport();
-      await this.server.connect(transport);
-      this.logger.info('ServiceNow Intelligent MCP Server running on stdio');
-    } catch (error) {
-      this.logger.error('Failed to start ServiceNow Intelligent MCP:', error);
-      process.exit(1);
-    }
-  }
-}
-
-const server = new ServiceNowIntelligentMCP();
-server.run().catch(console.error);