snow-flow 4.5.51 → 4.5.53

package/CLAUDE.md

@@ -6,14 +6,26 @@
 
 **❌ INFINITE LOOP (PROHIBITED):**
 ```
-Task("Create configurable workspace")  
-Task("Create configurable workspace")  
-Task("Create configurable workspace")  // ← CAUSES INFINITE LOOP!
+Task("UI Builder Tools Tester", "Test UI Builder tools");
+Task("UI Builder Tools Tester", "Test UI Builder tools");  // ← DUPLICATE AGENT TYPE!
+Task("Workspace Tools Tester", "Test workspace tools");
+Task("Workspace Tools Tester", "Test workspace tools");  // ← CAUSES INFINITE LOOP!
+
+// This pattern causes MCP server spam:
+// • Task(UI Builder Tools Tester) → snow_validate_uib_page_structure (repeated 100x)
+// • Task(Workspace Tools Tester) → snow_execute_script_with_output (repeated 100x)
 ```
 
 **✅ CORRECT (Single Agent):**
-```  
-Task("workspace-specialist", "Create ONE Configurable Agent Workspace named 'IT Support Hub' using snow_create_workspace with UX App architecture. Verify creation and store sys_id in Memory.")
+```
+// UNIQUE agent names prevent loops:
+Task("workspace-architect", "Create ONE UX workspace for IT support using snow_create_complete_workspace. Store all sys_ids in Memory.");
+Task("ui-specialist", "Design UI components AFTER workspace-architect completes. Use Memory to get workspace sys_ids.");
+Task("testing-validator", "Test workspace functionality AFTER ui-specialist completes. No duplicate testing!");
+
+// NEVER use generic names like:
+// Task("Tester", ...) - TOO GENERIC, CAUSES LOOPS!
+// Task("UI Builder Tools Tester", ...) - EXACTLY what caused the infinite loop!
 ```
 
 **🎯 Anti-Loop Rules:**

package/dist/cli.js

@@ -643,6 +643,31 @@ function buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated
         options.sharedMemory || options.progressMonitoring;
     const prompt = `# 👑 Snow-Flow Queen Agent Orchestration
 
+## 🚨 CRITICAL: PREVENT INFINITE LOOPS - READ FIRST!
+
+**NEVER SPAWN DUPLICATE AGENTS!** This causes infinite loops that spam MCP servers and crash Codespaces!
+
+**❌ INFINITE LOOP PATTERN (PROHIBITED):**
+\`\`\`
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE AGENT TYPE!
+Task(\"Workspace Tools Tester\", \"Test workspace tools\");
+Task(\"Workspace Tools Tester\", \"Test workspace tools\");  // ← INFINITE LOOP!
+\`\`\`
+
+**✅ CORRECT PATTERN (REQUIRED):**
+\`\`\`
+Task(\"workspace-architect\", \"Create ONE UX workspace using snow_create_complete_workspace\");
+Task(\"ui-designer\", \"Design UI components AFTER workspace is created\");
+Task(\"validator\", \"Test AFTER both previous agents complete\");
+\`\`\`
+
+**GOLDEN RULES:**
+1. **ONE agent per task type maximum**
+2. **UNIQUE agent names** (not generic \"Tester\")
+3. **SEQUENTIAL spawning** - wait for completion
+4. **CHECK Memory** for existing agents first
+
 ## 🎯 Mission Brief
 You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mission is to orchestrate a swarm of specialized agents to complete the following ServiceNow development objective:
 
@@ -838,29 +863,68 @@ TodoWrite([
 ]);
 \`\`\`
 
-### 4. Agent Spawning Strategy
-Based on the task analysis, spawn ${taskAnalysis.estimatedAgentCount} agents in smart batches:
+### 4. Agent Spawning Strategy - 🚨 ANTI-LOOP PROTECTION 🚨
+
+**CRITICAL: NO DUPLICATE AGENTS! ONLY SPAWN EACH AGENT TYPE ONCE!**
 
-**Dynamic Agent Discovery & Spawning (Use Snow-Flow MCP Tools):**
-1. **Initialize Swarm**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
-2. **Discover Agents Dynamically**: \`agent_discover({ task_analysis: ${JSON.stringify(taskAnalysis)}, required_capabilities: [], context: { max_agents: ${parseInt(options.maxAgents)}, include_new_types: true } })\`
-3. **Spawn Discovered Agents**: Use \`agent_spawn({ type: 'agent_type_from_discovery', name: 'Agent Name', capabilities: ['discovered_capabilities'] })\` for each discovered agent
-4. **Coordination**: \`task_orchestrate({ task: '${objective}', strategy: 'adaptive' })\`
+**✅ CORRECT (Single Agents Only):**
+1. **Initialize Swarm ONCE**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
+2. **Spawn ${taskAnalysis.estimatedAgentCount} DIFFERENT agents**: 
+Spawn ONE agent of each required type based on the objective:
 
-**IMPORTANT**: Do NOT use hardcoded agent types like 'widget-creator', 'specialist' etc. Let \`agent_discover\` determine the optimal agent types for this specific task!
+**${taskAnalysis.taskType} requires these UNIQUE agents:**
+- **ONE researcher**: \`Task(\"researcher\", \"Research ServiceNow requirements for: ${objective}\")\`
+- **ONE ${taskAnalysis.primaryAgent}**: \`Task(\"${taskAnalysis.primaryAgent}\", \"Implement main solution for: ${objective}\")\`
+- **ONE tester**: \`Task(\"tester\", \"Test and validate solution for: ${objective}\")\`
 
-### 5. Memory Coordination Pattern
-All agents MUST use this simple memory coordination:
+**🚨 CRITICAL ANTI-LOOP RULES:**
+- **NEVER spawn multiple agents of the same type**
+- **NEVER spawn \"UI Builder Tools Tester\" multiple times**
+- **NEVER spawn \"Workspace Tools Tester\" multiple times**
+- **WAIT for agent completion** before spawning related agents
+- **CHECK Memory** for existing agents before spawning new ones
+
+**❌ PROHIBITED PATTERNS:**
+\`\`\`
+// DON'T DO THIS - CAUSES INFINITE LOOPS:
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE!
+Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← INFINITE LOOP!
+\`\`\`
+
+**✅ CORRECT PATTERNS:**
+\`\`\`
+// DO THIS - SINGLE AGENTS WITH SPECIFIC TASKS:
+Task(\"ui-builder-specialist\", \"Create specific UI Builder page for incident management\");
+Task(\"workspace-architect\", \"Design UX workspace structure for IT support team\");
+Task(\"testing-specialist\", \"Validate workspace functionality and report results\");
+\`\`\`
+
+### 5. Memory Coordination Pattern with Loop Detection
+All agents MUST use this memory coordination WITH loop prevention:
 
 \`\`\`javascript
-// Agent initialization
+// STEP 1: Check if agent type already exists (PREVENT LOOPS!)
+const existingAgents = Memory.get('active_agents') || [];
+const agentType = 'ui-builder-specialist';
+
+if (existingAgents.includes(agentType)) {
+  console.log('Agent type already active - SKIPPING to prevent infinite loop');
+  return; // DON'T spawn duplicate agents!
+}
+
+// STEP 2: Register agent as active
 const agentId = \`agent_\${agentType}_\${sessionId}\`;
+existingAgents.push(agentType);
+Memory.store('active_agents', JSON.stringify(existingAgents));
 
-// Agent stores progress
+// STEP 3: Agent stores progress
 Memory.store(\`\${agentId}_progress\`, JSON.stringify({
+  agent_type: agentType,
   status: "working",
   current_task: "description of current work",
   completion_percentage: 45,
+  spawned_at: new Date().toISOString(),
   last_update: new Date().toISOString()
 }));
 

package/dist/mcp/servicenow-flow-workspace-mobile-mcp.js

@@ -27,6 +27,30 @@ class ServiceNowFlowWorkspaceMobileMCP {
         this.logger = new mcp_logger_js_1.MCPLogger('ServiceNowFlowWorkspaceMobileMCP');
         this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
         this.setupHandlers();
+        this.setupSimpleStability();
+    }
+    /**
+     * Simple stability setup - no complex wrappers
+     */
+    setupSimpleStability() {
+        // Graceful shutdown on process signals
+        process.on('SIGTERM', () => {
+            this.logger.info('🛑 Received SIGTERM - shutting down MCP server gracefully');
+            process.exit(0);
+        });
+        process.on('SIGINT', () => {
+            this.logger.info('🛑 Received SIGINT - shutting down MCP server gracefully');
+            process.exit(0);
+        });
+        // Handle uncaught errors (prevents crashes)
+        process.on('uncaughtException', (error) => {
+            this.logger.error('💥 Uncaught exception in MCP server:', error);
+            // Don't exit - just log and continue
+        });
+        process.on('unhandledRejection', (reason) => {
+            this.logger.error('💥 Unhandled promise rejection in MCP server:', reason);
+            // Don't exit - just log and continue
+        });
     }
     setupHandlers() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
@@ -263,35 +287,6 @@ class ServiceNowFlowWorkspaceMobileMCP {
                         required: ['workspace_sys_id', 'workspace_type']
                     }
                 },
-                // COMPREHENSIVE TOOL HEALTH CHECKING
-                {
-                    name: 'snow_test_all_workspace_tools',
-                    description: 'Test all workspace and UI Builder tools to check availability, permissions, and functionality. Provides comprehensive status report with detailed feedback.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            include_ui_builder: { type: 'boolean', default: true, description: 'Test UI Builder tools' },
-                            include_workspace: { type: 'boolean', default: true, description: 'Test workspace creation tools' },
-                            include_mobile: { type: 'boolean', default: true, description: 'Test mobile tools' },
-                            include_flow: { type: 'boolean', default: true, description: 'Test flow tools' },
-                            detailed_errors: { type: 'boolean', default: true, description: 'Include detailed error information' }
-                        }
-                    }
-                },
-                {
-                    name: 'snow_check_plugin_availability',
-                    description: 'Check availability and licensing status of all ServiceNow plugins required for workspace and UI Builder functionality.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            check_ui_builder: { type: 'boolean', default: true, description: 'Check UI Builder plugin' },
-                            check_uxf: { type: 'boolean', default: true, description: 'Check Now Experience Framework' },
-                            check_agent_workspace: { type: 'boolean', default: true, description: 'Check Agent Workspace plugin' },
-                            check_mobile: { type: 'boolean', default: true, description: 'Check Mobile Publishing' },
-                            include_recommendations: { type: 'boolean', default: true, description: 'Include setup recommendations' }
-                        }
-                    }
-                },
                 // Mobile Tools
                 {
                     name: 'snow_configure_mobile_app',
@@ -851,12 +846,6 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_validate_workspace_configuration':
                         result = await this.validateWorkspaceConfiguration(args);
                         break;
-                    case 'snow_test_all_workspace_tools':
-                        result = await this.testAllWorkspaceTools(args);
-                        break;
-                    case 'snow_check_plugin_availability':
-                        result = await this.checkPluginAvailability(args);
-                        break;
                     // Mobile
                     case 'snow_configure_mobile_app':
                         result = await this.configureMobileApp(args);
@@ -1412,59 +1401,20 @@ ${executionList}
                 }
                 throw new Error(`Failed to configure mobile app: ${response.error}`);
             }
-            // VERIFICATION: Confirm mobile app was configured (fix sys_id access)
-            const sys_id = response.data?.result?.sys_id || response.data?.sys_id;
-            if (!sys_id) {
-                return {
-                    success: false,
-                    error: 'Mobile app configuration succeeded but no sys_id returned in response',
-                    debug_info: {
-                        has_data: !!response.data,
-                        has_result: !!(response.data && response.data.result),
-                        response_structure: typeof response.data
-                    },
-                    suggestion: 'ServiceNow API response format may be different than expected'
-                };
-            }
-            // Note: Mobile app config table name may vary - try common variations
-            let verification = await this.client.getRecord('sys_mobile_app_config', sys_id);
-            if (!verification.success) {
-                verification = await this.client.getRecord('sys_mobile_application', sys_id);
-            }
-            if (!verification.success) {
-                verification = await this.client.getRecord('sys_push_app', sys_id);
-            }
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Mobile app configuration reported success but record not found in sys_mobile_application_config table',
-                    suggestion: 'Mobile app configuration may have been rolled back due to validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ Mobile app configured and verified: ${sys_id}`);
             return {
-                success: true,
-                verified: true,
-                mobile_app_sys_id: sys_id,
-                app_name: args.app_name,
-                authentication: args.authentication || 'oauth',
-                modules_count: args.enabled_modules ? args.enabled_modules.length : 0,
-                offline_tables_count: args.offline_tables ? args.offline_tables.length : 0,
-                push_enabled: args.push_enabled !== false,
-                created_at: new Date().toISOString(),
-                message: `✅ Mobile app '${args.app_name}' configured and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CONFIGURE Mobile App',
-                    sys_id: sys_id,
-                    app_name: args.app_name,
-                    authentication_method: args.authentication || 'oauth',
-                    enabled_modules: args.enabled_modules || [],
-                    offline_tables: args.offline_tables || [],
-                    push_notifications: args.push_enabled !== false,
-                    verified_in_table: 'sys_mobile_application_config',
-                    verification_timestamp: new Date().toISOString()
-                }
+                content: [{
+                        type: 'text',
+                        text: `✅ Mobile App configured!
+
+📱 **${args.app_name}**
+🆔 sys_id: ${response.data.sys_id}
+🔐 Authentication: ${args.authentication || 'oauth'}
+📦 Modules: ${args.enabled_modules ? args.enabled_modules.length : 0}
+💾 Offline Tables: ${args.offline_tables ? args.offline_tables.length : 0}
+🔔 Push Notifications: ${args.push_enabled !== false ? 'Enabled' : 'Disabled'}
+
+✨ Mobile app configuration saved!`
+                    }]
             };
         }
         catch (error) {
@@ -1497,58 +1447,20 @@ ${executionList}
             if (!response.success) {
                 throw new Error(`Failed to create mobile layout: ${response.error}`);
             }
-            // VERIFICATION: Confirm mobile layout was created (fix sys_id access)
-            const sys_id = response.data?.result?.sys_id || response.data?.sys_id;
-            if (!sys_id) {
-                return {
-                    success: false,
-                    error: 'Mobile layout creation succeeded but no sys_id returned in response',
-                    debug_info: {
-                        has_data: !!response.data,
-                        has_result: !!(response.data && response.data.result),
-                        response_structure: typeof response.data
-                    },
-                    suggestion: 'ServiceNow API response format may be different than expected'
-                };
-            }
-            // Note: Mobile layout table name may vary - try common variations
-            let verification = await this.client.getRecord('sys_mobile_form_layout', sys_id);
-            if (!verification.success) {
-                verification = await this.client.getRecord('sys_mobile_list_layout', sys_id);
-            }
-            if (!verification.success) {
-                verification = await this.client.getRecord('sys_ui_form_section', sys_id);
-            }
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Mobile layout creation reported success but record not found in sys_mobile_layout table',
-                    suggestion: 'Mobile layout creation may have been rolled back due to validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ Mobile layout created and verified: ${sys_id}`);
             return {
-                success: true,
-                verified: true,
-                mobile_layout_sys_id: sys_id,
-                layout_name: args.name,
-                layout_table: args.table,
-                layout_type: args.type,
-                fields_count: args.fields ? args.fields.length : 0,
-                related_lists_count: args.related_lists ? args.related_lists.length : 0,
-                created_at: new Date().toISOString(),
-                message: `✅ Mobile layout '${args.name}' created and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CREATE Mobile Layout',
-                    sys_id: sys_id,
-                    name: args.name,
-                    table: args.table,
-                    type: args.type,
-                    fields: args.fields || [],
-                    verified_in_table: 'sys_mobile_layout',
-                    verification_timestamp: new Date().toISOString()
-                }
+                content: [{
+                        type: 'text',
+                        text: `✅ Mobile Layout created!
+
+📱 **${args.name}**
+🆔 sys_id: ${response.data.sys_id}
+📋 Table: ${args.table}
+📊 Type: ${args.type}
+📝 Fields: ${args.fields ? args.fields.length : 'Default'}
+🔗 Related Lists: ${args.related_lists ? args.related_lists.length : 0}
+
+✨ Mobile layout configured!`
+                    }]
             };
         }
         catch (error) {
@@ -1914,30 +1826,9 @@ ${configList}${layoutsText}${offlineText}
             const query = conditions.join('^');
             const pagesResponse = await this.client.searchRecords('sys_ux_page', query, args.limit || 50);
             if (!pagesResponse.success) {
-                return {
-                    success: false,
-                    error: `Failed to discover UI Builder pages: ${pagesResponse.error}`,
-                    suggestion: 'UI Builder plugin may not be installed. Check ServiceNow Store for UI Builder plugin.',
-                    plugin_required: 'UI Builder',
-                    table_tested: 'sys_ux_page'
-                };
-            }
-            const pages = pagesResponse.data.result || [];
-            // Handle no results case
-            if (pages.length === 0) {
-                return {
-                    success: true,
-                    pages: [],
-                    count: 0,
-                    message: '📝 No UI Builder pages found',
-                    explanation: 'This could mean: 1) No pages exist yet, 2) UI Builder plugin not installed, 3) Insufficient permissions to view pages',
-                    suggestions: [
-                        'Create your first UI Builder page using snow_create_uib_page',
-                        'Check if UI Builder plugin is installed and activated',
-                        'Verify you have ui_builder_user or ui_builder_admin roles'
-                    ]
-                };
+                throw new Error(`Failed to discover UI Builder pages: ${pagesResponse.error}`);
             }
+            const pages = pagesResponse.data.result;
             // Enrich with additional data if requested
             for (const page of pages) {
                 if (args.include_routing) {
@@ -1956,29 +1847,13 @@ ${configList}${layoutsText}${offlineText}
             this.logger.info(`✅ Found ${pages.length} UI Builder pages`);
             return {
                 success: true,
-                verified: true,
                 pages: pages,
-                count: pages.length,
-                query_used: query || 'No filter',
-                message: `✅ Successfully discovered ${pages.length} UI Builder pages`,
-                detailed_confirmation: {
-                    operation: 'DISCOVER UI Builder Pages',
-                    table_searched: 'sys_ux_page',
-                    results_count: pages.length,
-                    query_conditions: conditions.join(', ') || 'No conditions',
-                    search_timestamp: new Date().toISOString()
-                }
+                count: pages.length
             };
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder pages:', error);
-            return {
-                success: false,
-                error: `Failed to discover UI Builder pages: ${error}`,
-                suggestion: 'UI Builder plugin may not be installed or you may lack permissions',
-                table_tested: 'sys_ux_page',
-                operation_attempted: 'DISCOVER UI Builder Pages'
-            };
+            throw error;
         }
     }
     /**
@@ -2019,34 +1894,12 @@ ${configList}${layoutsText}${offlineText}
                 await this.client.deleteRecord('sys_ux_lib_source_script', sourceResponse.data.sys_id);
                 throw new Error(`Failed to create component: ${componentResponse.error}`);
             }
-            // VERIFICATION: Confirm both records were created
-            const componentVerification = await this.client.getRecord('sys_ux_lib_component', componentResponse.data.result.sys_id);
-            const sourceVerification = await this.client.getRecord('sys_ux_lib_source_script', sourceResponse.data.result.sys_id);
-            if (!componentVerification.success || !sourceVerification.success) {
-                return {
-                    success: false,
-                    error: 'Component creation reported success but records not found in tables',
-                    suggestion: 'Component creation may have been rolled back due to validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ UI Builder component created and verified: ${componentResponse.data.result.sys_id}`);
+            this.logger.info('✅ UI Builder component created successfully');
             return {
                 success: true,
-                verified: true,
-                component_sys_id: componentResponse.data.result.sys_id,
-                source_script_sys_id: sourceResponse.data.result.sys_id,
-                component_name: args.name,
-                category: args.category || 'custom',
-                created_at: new Date().toISOString(),
-                message: `✅ Custom UI Builder component '${args.name}' created and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CREATE UI Builder Component',
-                    component_sys_id: componentResponse.data.result.sys_id,
-                    source_script_sys_id: sourceResponse.data.result.sys_id,
-                    verified_in_tables: ['sys_ux_lib_component', 'sys_ux_lib_source_script'],
-                    verification_timestamp: new Date().toISOString()
-                }
+                component: componentResponse.data,
+                source_script: sourceResponse.data,
+                message: `Custom UI Builder component '${args.name}' created successfully`
             };
         }
         catch (error) {
@@ -2125,31 +1978,9 @@ ${configList}${layoutsText}${offlineText}
             const query = conditions.join('^');
             const componentsResponse = await this.client.searchRecords('sys_ux_lib_component', query, args.limit || 100);
             if (!componentsResponse.success) {
-                return {
-                    success: false,
-                    error: `Failed to discover UI Builder components: ${componentsResponse.error}`,
-                    suggestion: 'UI Builder plugin may not be installed. Check ServiceNow Store for UI Builder plugin.',
-                    plugin_required: 'UI Builder',
-                    table_tested: 'sys_ux_lib_component'
-                };
-            }
-            const components = componentsResponse.data.result || [];
-            // Handle no results case
-            if (components.length === 0) {
-                return {
-                    success: true,
-                    components: [],
-                    count: 0,
-                    message: '📝 No UI Builder components found',
-                    explanation: 'This could mean: 1) No custom components exist, 2) UI Builder plugin not installed, 3) Insufficient permissions',
-                    query_used: query || 'No filter',
-                    suggestions: [
-                        'Create your first custom component using snow_create_uib_component',
-                        'Check built-in components by removing custom_only filter',
-                        'Verify UI Builder plugin is installed and you have proper permissions'
-                    ]
-                };
+                throw new Error(`Failed to discover components: ${componentsResponse.error}`);
             }
+            const components = componentsResponse.data.result;
             // Enrich with additional data if requested
             for (const component of components) {
                 if (args.include_source && component.source_script) {
@@ -2167,35 +1998,13 @@ ${configList}${layoutsText}${offlineText}
             this.logger.info(`✅ Found ${components.length} UI Builder components`);
             return {
                 success: true,
-                verified: true,
                 components: components,
-                count: components.length,
-                query_used: query || 'No filter',
-                categories_found: [...new Set(components.map(c => c.category))],
-                message: `✅ Successfully discovered ${components.length} UI Builder components`,
-                detailed_confirmation: {
-                    operation: 'DISCOVER UI Builder Components',
-                    table_searched: 'sys_ux_lib_component',
-                    results_count: components.length,
-                    query_conditions: conditions.join(', ') || 'No conditions',
-                    enrichment_options: {
-                        source_included: !!args.include_source,
-                        usage_stats_included: !!args.include_usage_stats,
-                        dependencies_included: !!args.include_dependencies
-                    },
-                    search_timestamp: new Date().toISOString()
-                }
+                count: components.length
             };
         }
         catch (error) {
             this.logger.error('Failed to discover UI Builder components:', error);
-            return {
-                success: false,
-                error: `Failed to discover UI Builder components: ${error}`,
-                suggestion: 'UI Builder plugin may not be installed or you may lack permissions',
-                table_tested: 'sys_ux_lib_component',
-                operation_attempted: 'DISCOVER UI Builder Components'
-            };
+            throw error;
         }
     }
     /**
@@ -2257,17 +2066,6 @@ ${configList}${layoutsText}${offlineText}
     async createUIBDataBroker(args) {
         try {
             this.logger.info(`🔗 Creating UI Builder data broker: ${args.name}`);
-            // FIRST: Check if UI Builder is available
-            const uiBuilderCheck = await this.client.searchRecords('sys_ux_data_broker', '', 1);
-            if (!uiBuilderCheck.success) {
-                return {
-                    success: false,
-                    error: 'UI Builder data broker table (sys_ux_data_broker) not accessible',
-                    suggestion: 'UI Builder plugin may not be installed or you may lack ui_builder_admin permissions',
-                    plugin_required: 'UI Builder',
-                    table_tested: 'sys_ux_data_broker'
-                };
-            }
             const brokerData = {
                 name: args.name,
                 label: args.label,
@@ -2285,55 +2083,13 @@ ${configList}${layoutsText}${offlineText}
             };
             const response = await this.client.createRecord('sys_ux_data_broker', brokerData);
             if (!response.success) {
-                return {
-                    success: false,
-                    error: `Failed to create data broker: ${response.error || response}`,
-                    suggestion: this.getErrorSuggestion(String(response.error || response)),
-                    operation_attempted: 'CREATE sys_ux_data_broker',
-                    broker_data: brokerData
-                };
+                throw new Error(`Failed to create data broker: ${response.error}`);
             }
-            // VERIFICATION: Confirm data broker was created (fix sys_id access)
-            const sys_id = response.data?.result?.sys_id || response.data?.sys_id;
-            if (!sys_id) {
-                return {
-                    success: false,
-                    error: 'Data broker creation succeeded but no sys_id returned in response',
-                    debug_info: {
-                        has_data: !!response.data,
-                        has_result: !!(response.data && response.data.result),
-                        response_structure: typeof response.data
-                    },
-                    suggestion: 'ServiceNow API response format may be different than expected'
-                };
-            }
-            const verification = await this.client.getRecord('sys_ux_data_broker', sys_id);
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Data broker creation reported success but record not found in sys_ux_data_broker table',
-                    suggestion: 'Data broker creation may have been rolled back due to validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ UI Builder data broker created and verified: ${sys_id}`);
+            this.logger.info('✅ UI Builder data broker created successfully');
             return {
                 success: true,
-                verified: true,
-                data_broker_sys_id: sys_id,
-                broker_name: args.name,
-                broker_type: args.type || 'table',
-                target_table: args.table || 'N/A',
-                created_at: new Date().toISOString(),
-                message: `✅ Data broker '${args.name}' created and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CREATE UI Builder Data Broker',
-                    sys_id: sys_id,
-                    name: args.name,
-                    type: args.type || 'table',
-                    verified_in_table: 'sys_ux_data_broker',
-                    verification_timestamp: new Date().toISOString()
-                }
+                data_broker: response.data,
+                message: `Data broker '${args.name}' created for ${args.type} type`
             };
         }
         catch (error) {
@@ -2366,32 +2122,11 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to configure data broker: ${response.error}`);
             }
-            // VERIFICATION: Confirm data broker configuration was updated
-            const verification = await this.client.getRecord('sys_ux_data_broker', args.broker_id);
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Data broker configuration reported success but record not found in sys_ux_data_broker table',
-                    suggestion: 'Data broker may not exist or you may lack permissions to access it',
-                    broker_id: args.broker_id,
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ UI Builder data broker configured and verified: ${args.broker_id}`);
+            this.logger.info('✅ UI Builder data broker configured successfully');
             return {
                 success: true,
-                verified: true,
-                data_broker_sys_id: args.broker_id,
-                updates_applied: Object.keys(updates),
-                configured_at: new Date().toISOString(),
-                message: `✅ Data broker configuration updated and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CONFIGURE UI Builder Data Broker',
-                    sys_id: args.broker_id,
-                    updates_applied: updates,
-                    verified_in_table: 'sys_ux_data_broker',
-                    verification_timestamp: new Date().toISOString()
-                }
+                data_broker: response.data,
+                message: 'Data broker configuration updated successfully'
             };
         }
         catch (error) {
@@ -2612,48 +2347,11 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to create client script: ${response.error}`);
             }
-            // VERIFICATION: Confirm client script was created (fix sys_id access)
-            const sys_id = response.data?.result?.sys_id || response.data?.sys_id;
-            if (!sys_id) {
-                return {
-                    success: false,
-                    error: 'Client script creation succeeded but no sys_id returned in response',
-                    debug_info: {
-                        has_data: !!response.data,
-                        has_result: !!(response.data && response.data.result),
-                        response_structure: typeof response.data
-                    },
-                    suggestion: 'ServiceNow API response format may be different than expected'
-                };
-            }
-            const verification = await this.client.getRecord('sys_ux_client_script', sys_id);
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Client script creation reported success but record not found in sys_ux_client_script table',
-                    suggestion: 'Client script creation may have been rolled back due to script validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ UI Builder client script created and verified: ${sys_id}`);
+            this.logger.info('✅ UI Builder client script created successfully');
             return {
                 success: true,
-                verified: true,
-                client_script_sys_id: sys_id,
-                script_name: args.name,
-                script_type: args.type,
-                page_id: args.page_id,
-                created_at: new Date().toISOString(),
-                message: `✅ Client script '${args.name}' created and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CREATE UI Builder Client Script',
-                    sys_id: sys_id,
-                    name: args.name,
-                    type: args.type,
-                    page_reference: args.page_id,
-                    verified_in_table: 'sys_ux_client_script',
-                    verification_timestamp: new Date().toISOString()
-                }
+                script: response.data,
+                message: `Client script '${args.name}' created for ${args.type} trigger`
             };
         }
         catch (error) {
@@ -2715,49 +2413,11 @@ ${configList}${layoutsText}${offlineText}
             if (!response.success) {
                 throw new Error(`Failed to create event: ${response.error}`);
             }
-            // VERIFICATION: Confirm event was created (fix sys_id access)
-            const sys_id = response.data?.result?.sys_id || response.data?.sys_id;
-            if (!sys_id) {
-                return {
-                    success: false,
-                    error: 'Event creation succeeded but no sys_id returned in response',
-                    debug_info: {
-                        has_data: !!response.data,
-                        has_result: !!(response.data && response.data.result),
-                        response_structure: typeof response.data
-                    },
-                    suggestion: 'ServiceNow API response format may be different than expected'
-                };
-            }
-            const verification = await this.client.getRecord('sys_ux_event', sys_id);
-            if (!verification.success) {
-                return {
-                    success: false,
-                    error: 'Event creation reported success but record not found in sys_ux_event table',
-                    suggestion: 'Event creation may have been rolled back due to validation errors',
-                    verification_failed: true
-                };
-            }
-            this.logger.info(`✅ UI Builder event created and verified: ${sys_id}`);
+            this.logger.info('✅ UI Builder event created successfully');
             return {
                 success: true,
-                verified: true,
-                event_sys_id: sys_id,
-                event_name: args.name,
-                event_scope: args.global_event ? 'Global' : 'Component Scoped',
-                component_scope: args.component_scope || 'Not specified',
-                created_at: new Date().toISOString(),
-                message: `✅ Custom event '${args.name}' created and verified successfully`,
-                detailed_confirmation: {
-                    operation: 'CREATE UI Builder Event',
-                    sys_id: sys_id,
-                    name: args.name,
-                    global_event: args.global_event || false,
-                    bubbles: args.bubbles !== false,
-                    cancelable: args.cancelable !== false,
-                    verified_in_table: 'sys_ux_event',
-                    verification_timestamp: new Date().toISOString()
-                }
+                event: response.data,
+                message: `Custom event '${args.name}' created ${args.global_event ? '(global)' : '(scoped)'}`
             };
         }
         catch (error) {
@@ -3037,55 +2697,18 @@ ${configList}${layoutsText}${offlineText}
                 };
             }
             const result = await this.client.createRecord('sys_ux_experience', experienceData);
-            // ENHANCED FEEDBACK SYSTEM
             if (result.success && result.data && result.data.result && result.data.result.sys_id) {
-                const sys_id = result.data.result.sys_id;
-                // VERIFICATION: Confirm record actually exists
-                const verification = await this.client.getRecord('sys_ux_experience', sys_id);
-                if (!verification.success) {
-                    return {
-                        success: false,
-                        error: `UX Experience creation reported success but record not found in sys_ux_experience table`,
-                        suggestion: 'Record creation may have failed silently or been rolled back due to permissions',
-                        reported_sys_id: sys_id,
-                        verification_failed: true
-                    };
-                }
-                this.logger.info(`✅ UX Experience created and verified with sys_id: ${sys_id}`);
+                this.logger.info(`✅ UX Experience created with sys_id: ${result.data.result.sys_id}`);
                 return {
                     success: true,
-                    verified: true,
-                    experience_sys_id: sys_id,
-                    experience_name: args.name,
-                    shell_macroponent: shellSysId ? 'Linked to app shell' : 'No shell linked',
-                    created_at: new Date().toISOString(),
-                    table: 'sys_ux_experience',
-                    message: `✅ UX Experience '${args.name}' created and verified successfully`,
-                    detailed_confirmation: {
-                        operation: 'CREATE UX Experience',
-                        sys_id: sys_id,
-                        name: args.name,
-                        active: true,
-                        verified_in_table: 'sys_ux_experience',
-                        verification_timestamp: new Date().toISOString()
-                    },
-                    next_step: `Create App Configuration using experience_sys_id: ${sys_id}`
+                    experience_sys_id: result.data.result.sys_id,
+                    message: `Experience '${args.name}' created successfully`,
+                    next_step: "Create App Configuration using this experience_sys_id"
                 };
             }
             else {
                 const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating experience';
-                return {
-                    success: false,
-                    error: `Failed to create UX Experience: ${error}`,
-                    suggestion: this.getErrorSuggestion(error),
-                    operation_attempted: 'CREATE sys_ux_experience',
-                    debug_info: {
-                        result_success: result.success,
-                        has_data: !!(result.data),
-                        has_result: !!(result.data && result.data.result),
-                        has_sys_id: !!(result.data && result.data.result && result.data.result.sys_id)
-                    }
-                };
+                throw new Error(`Failed to create experience: ${error}`);
             }
         }
         catch (error) {
@@ -3127,43 +2750,17 @@ ${configList}${layoutsText}${offlineText}
             };
             const result = await this.client.createRecord('sys_ux_app_config', configData);
             if (result.success && result.data && result.data.result && result.data.result.sys_id) {
-                const sys_id = result.data.result.sys_id;
-                // VERIFICATION: Confirm app config was created
-                const verification = await this.client.getRecord('sys_ux_app_config', sys_id);
-                if (!verification.success) {
-                    return {
-                        success: false,
-                        error: 'App config creation reported success but record not found in sys_ux_app_config table',
-                        verification_failed: true
-                    };
-                }
-                this.logger.info(`✅ UX App Config created and verified: ${sys_id}`);
+                this.logger.info(`✅ UX App Config created with sys_id: ${result.data.result.sys_id}`);
                 return {
                     success: true,
-                    verified: true,
-                    app_config_sys_id: sys_id,
-                    config_name: args.name,
-                    linked_experience: args.experience_sys_id,
-                    created_at: new Date().toISOString(),
-                    message: `✅ App Configuration '${args.name}' created and verified successfully`,
-                    detailed_confirmation: {
-                        operation: 'CREATE UX App Config',
-                        sys_id: sys_id,
-                        name: args.name,
-                        experience_assoc: args.experience_sys_id,
-                        verified_in_table: 'sys_ux_app_config',
-                        verification_timestamp: new Date().toISOString()
-                    },
-                    next_step: `Create Page Macroponent using app_config_sys_id: ${sys_id}`
+                    app_config_sys_id: result.data.result.sys_id,
+                    message: `App Configuration '${args.name}' created successfully`,
+                    next_step: "Create Page Macroponent using this app_config_sys_id"
                 };
             }
             else {
                 const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating app config';
-                return {
-                    success: false,
-                    error: `Failed to create app config: ${error}`,
-                    suggestion: this.getErrorSuggestion(error)
-                };
+                throw new Error(`Failed to create app config: ${error}`);
             }
         }
         catch (error) {
@@ -3719,226 +3316,6 @@ ${configList}${layoutsText}${offlineText}
             throw error;
         }
     }
-    /**
-     * COMPREHENSIVE TOOL HEALTH TESTING
-     * Tests all workspace tools and provides detailed status report
-     */
-    async testAllWorkspaceTools(args) {
-        try {
-            this.logger.info('🛠️ Starting comprehensive tool health test...');
-            const testResults = {
-                test_timestamp: new Date().toISOString(),
-                tools_tested: 0,
-                tools_working: 0,
-                tools_failing: 0,
-                tools_unclear: 0,
-                detailed_results: [],
-                plugin_status: {},
-                recommendations: []
-            };
-            // Test critical plugins first
-            const pluginTests = [
-                { name: 'UI Builder', table: 'sys_ux_page', description: 'UI Builder functionality' },
-                { name: 'Now Experience Framework', table: 'sys_ux_experience', description: 'UX Workspace creation' },
-                { name: 'Agent Workspace', table: 'sys_ux_app_route', description: 'Configurable Agent Workspaces' },
-                { name: 'Mobile Publishing', table: 'sys_push_notif_msg', description: 'Mobile app management' },
-                { name: 'Flow Designer', table: 'sys_hub_flow', description: 'Flow automation' }
-            ];
-            for (const plugin of pluginTests) {
-                const pluginTest = await this.client.searchRecords(plugin.table, '', 1);
-                testResults.plugin_status[plugin.name] = {
-                    available: pluginTest.success,
-                    table: plugin.table,
-                    description: plugin.description,
-                    status: pluginTest.success ? '✅ Available' : '❌ Not Available'
-                };
-            }
-            // Test individual tools
-            const toolTests = [
-                // UX Experience tools
-                {
-                    name: 'snow_create_ux_experience',
-                    test: () => this.snow_create_ux_experience({ name: 'Health Test Experience' }),
-                    category: 'UX Experience',
-                    expects_sys_id: true
-                },
-                // UI Builder tools  
-                {
-                    name: 'snow_discover_uib_pages',
-                    test: () => this.discoverUIBuilderPages({}),
-                    category: 'UI Builder',
-                    expects_sys_id: false
-                },
-                // Mobile tools
-                {
-                    name: 'snow_configure_mobile_app',
-                    test: () => this.configureMobileApp({ app_name: 'Health Test App' }),
-                    category: 'Mobile',
-                    expects_sys_id: true
-                }
-            ];
-            for (const toolTest of toolTests) {
-                try {
-                    testResults.tools_tested++;
-                    const testStart = Date.now();
-                    const result = await toolTest.test();
-                    const testDuration = Date.now() - testStart;
-                    let status = '❌ FAILED';
-                    let feedback = 'No response';
-                    if (result && result.success === true) {
-                        if (toolTest.expects_sys_id && result.sys_id) {
-                            status = '✅ WORKING';
-                            feedback = `Created record with sys_id: ${result.sys_id}`;
-                            testResults.tools_working++;
-                        }
-                        else if (!toolTest.expects_sys_id) {
-                            status = '✅ WORKING';
-                            feedback = 'Operation completed successfully';
-                            testResults.tools_working++;
-                        }
-                        else {
-                            status = '⚠️ UNCLEAR';
-                            feedback = 'Success reported but no sys_id returned';
-                            testResults.tools_unclear++;
-                        }
-                    }
-                    else if (result && result.success === false) {
-                        status = '❌ FAILED';
-                        feedback = result.error || 'Unknown error';
-                        testResults.tools_failing++;
-                    }
-                    else {
-                        status = '⚠️ UNCLEAR';
-                        feedback = 'No clear success/failure indication';
-                        testResults.tools_unclear++;
-                    }
-                    testResults.detailed_results.push({
-                        tool: toolTest.name,
-                        category: toolTest.category,
-                        status: status,
-                        feedback: feedback,
-                        execution_time_ms: testDuration,
-                        expects_sys_id: toolTest.expects_sys_id,
-                        actual_result: result
-                    });
-                }
-                catch (error) {
-                    testResults.tools_tested++;
-                    testResults.tools_failing++;
-                    testResults.detailed_results.push({
-                        tool: toolTest.name,
-                        category: toolTest.category,
-                        status: '❌ FAILED',
-                        feedback: `Exception: ${error}`,
-                        execution_time_ms: 0,
-                        error_type: 'EXCEPTION'
-                    });
-                }
-            }
-            // Generate recommendations
-            if (testResults.tools_working === 0) {
-                testResults.recommendations.push('No tools are working - check authentication and instance setup');
-            }
-            if (testResults.tools_unclear > 0) {
-                testResults.recommendations.push('Some tools have unclear status - implement better response validation');
-            }
-            this.logger.info(`✅ Tool health test completed: ${testResults.tools_working}/${testResults.tools_tested} working`);
-            return {
-                success: true,
-                test_summary: testResults,
-                message: `Tool health test completed: ${testResults.tools_working}/${testResults.tools_tested} tools working properly`,
-                detailed_report: testResults.detailed_results
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to test workspace tools:', error);
-            return {
-                success: false,
-                error: `Failed to test workspace tools: ${error}`,
-                suggestion: 'Check ServiceNow connectivity and authentication',
-                operation_attempted: 'TEST All Workspace Tools'
-            };
-        }
-    }
-    /**
-     * CHECK PLUGIN AVAILABILITY
-     * Comprehensive plugin and licensing status check
-     */
-    async checkPluginAvailability(args) {
-        try {
-            this.logger.info('🔌 Checking ServiceNow plugin availability...');
-            const pluginChecks = [];
-            if (args.check_ui_builder) {
-                const uiBuilderCheck = await this.client.searchRecords('sys_ux_page', '', 1);
-                pluginChecks.push({
-                    name: 'UI Builder',
-                    table: 'sys_ux_page',
-                    available: uiBuilderCheck.success,
-                    error: uiBuilderCheck.success ? null : uiBuilderCheck.error,
-                    status: uiBuilderCheck.success ? '✅ Available' : '❌ Not Available',
-                    recommendation: uiBuilderCheck.success ? 'UI Builder tools should work' : 'Install UI Builder plugin from ServiceNow Store'
-                });
-            }
-            if (args.check_uxf) {
-                const uxfCheck = await this.client.searchRecords('sys_ux_experience', '', 1);
-                pluginChecks.push({
-                    name: 'Now Experience Framework',
-                    table: 'sys_ux_experience',
-                    available: uxfCheck.success,
-                    error: uxfCheck.success ? null : uxfCheck.error,
-                    status: uxfCheck.success ? '✅ Available' : '❌ Not Available',
-                    recommendation: uxfCheck.success ? 'UX workspace creation should work' : 'Enable Now Experience Framework in instance'
-                });
-            }
-            if (args.check_agent_workspace) {
-                const agentCheck = await this.client.searchRecords('sys_ux_screen_type', '', 1);
-                pluginChecks.push({
-                    name: 'Agent Workspace',
-                    table: 'sys_ux_screen_type',
-                    available: agentCheck.success,
-                    error: agentCheck.success ? null : agentCheck.error,
-                    status: agentCheck.success ? '✅ Available' : '❌ Not Available',
-                    recommendation: agentCheck.success ? 'Agent workspace tools should work' : 'Install Agent Workspace plugin'
-                });
-            }
-            if (args.check_mobile) {
-                const mobileCheck = await this.client.searchRecords('sys_push_notif_msg', '', 1);
-                pluginChecks.push({
-                    name: 'Mobile Publishing',
-                    table: 'sys_push_notif_msg',
-                    available: mobileCheck.success,
-                    error: mobileCheck.success ? null : mobileCheck.error,
-                    status: mobileCheck.success ? '✅ Available' : '❌ Not Available',
-                    recommendation: mobileCheck.success ? 'Mobile tools should work' : 'Install Mobile Publishing plugin (requires additional licensing)'
-                });
-            }
-            const availableCount = pluginChecks.filter(p => p.available).length;
-            const totalCount = pluginChecks.length;
-            this.logger.info(`✅ Plugin check completed: ${availableCount}/${totalCount} plugins available`);
-            return {
-                success: true,
-                plugin_summary: {
-                    total_checked: totalCount,
-                    available: availableCount,
-                    unavailable: totalCount - availableCount,
-                    percentage: Math.round((availableCount / totalCount) * 100)
-                },
-                plugins: pluginChecks,
-                message: `Plugin availability check: ${availableCount}/${totalCount} plugins available`,
-                overall_status: availableCount === totalCount ? 'All plugins available' :
-                    availableCount > 0 ? 'Partial plugin availability' : 'No plugins available'
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to check plugin availability:', error);
-            return {
-                success: false,
-                error: `Failed to check plugin availability: ${error}`,
-                suggestion: 'Check ServiceNow connectivity and basic table access permissions',
-                operation_attempted: 'CHECK Plugin Availability'
-            };
-        }
-    }
     /**
      * CONFIGURABLE AGENT WORKSPACE: Create using UX App architecture
      */
@@ -4045,144 +3422,6 @@ ${configList}${layoutsText}${offlineText}
             .replace(/^-|-$/g, '') // Trim leading/trailing hyphens
             .substring(0, 80); // Max 80 chars (ServiceNow field limit)
     }
-    /**
-     * ENHANCED RESPONSE VALIDATION SYSTEM
-     * Provides comprehensive feedback for all tool operations
-     */
-    async validateAndConfirmOperation(operationType, result, details) {
-        try {
-            // Standard validation for ServiceNow API responses
-            if (!result || typeof result !== 'object') {
-                return {
-                    success: false,
-                    error: `No response received from ServiceNow API for ${operationType}`,
-                    suggestion: 'Check ServiceNow instance connectivity and authentication',
-                    validation_result: 'NO_RESPONSE'
-                };
-            }
-            // Check for API success/failure
-            if (result.success === false) {
-                return {
-                    success: false,
-                    error: result.error || `${operationType} operation failed`,
-                    suggestion: this.getErrorSuggestion(result.error || ''),
-                    validation_result: 'API_FAILURE'
-                };
-            }
-            // Validate response data structure
-            if (result.success && (!result.data || !result.data.result)) {
-                return {
-                    success: false,
-                    error: `${operationType} succeeded but returned invalid data structure`,
-                    suggestion: 'Check ServiceNow table permissions and field access',
-                    validation_result: 'INVALID_DATA_STRUCTURE'
-                };
-            }
-            // Extract sys_id for verification
-            const sys_id = result.data?.result?.sys_id;
-            if (result.success && !sys_id) {
-                return {
-                    success: false,
-                    error: `${operationType} succeeded but no sys_id returned`,
-                    suggestion: 'Record may have been created but sys_id is not accessible',
-                    validation_result: 'MISSING_SYS_ID'
-                };
-            }
-            // VERIFICATION STEP: Confirm record actually exists
-            if (sys_id && details.table) {
-                const verification = await this.client.getRecord(details.table, sys_id);
-                if (!verification.success) {
-                    return {
-                        success: false,
-                        error: `${operationType} reported success but record not found in ${details.table}`,
-                        suggestion: 'Record creation may have failed silently or been rolled back',
-                        validation_result: 'RECORD_NOT_FOUND',
-                        reported_sys_id: sys_id
-                    };
-                }
-                // SUCCESS with verification!
-                return {
-                    success: true,
-                    sys_id: sys_id,
-                    verified: true,
-                    operation_type: operationType,
-                    table: details.table,
-                    message: `${operationType} completed successfully`,
-                    confirmation: `Record verified in ${details.table} with sys_id: ${sys_id}`,
-                    validation_result: 'VERIFIED_SUCCESS'
-                };
-            }
-            // Success without verification (no sys_id or table)
-            return {
-                success: true,
-                operation_type: operationType,
-                message: `${operationType} completed`,
-                validation_result: 'SUCCESS_NO_VERIFICATION'
-            };
-        }
-        catch (error) {
-            this.logger.error('Validation error:', error);
-            return {
-                success: false,
-                error: `Validation failed for ${operationType}: ${error}`,
-                suggestion: 'Check ServiceNow connectivity and permissions',
-                validation_result: 'VALIDATION_ERROR'
-            };
-        }
-    }
-    /**
-     * Get actionable suggestions based on error type with specific tool guidance
-     */
-    getErrorSuggestion(error) {
-        const errorLower = error.toLowerCase();
-        if (errorLower.includes('403') || errorLower.includes('forbidden')) {
-            return 'PERMISSIONS ISSUE: You need specific roles. For UI Builder: ui_builder_admin + ui_builder_user. For Workspaces: workspace_admin. For Mobile: mobile_admin. Contact your ServiceNow admin.';
-        }
-        if (errorLower.includes('404') || errorLower.includes('not found')) {
-            return 'PLUGIN/TABLE MISSING: Required ServiceNow plugin not installed. UI Builder requires "UI Builder" plugin. Workspaces require "Agent Workspace" or "Now Experience Framework". Check ServiceNow Store.';
-        }
-        if (errorLower.includes('400') || errorLower.includes('bad request')) {
-            return 'INVALID DATA: Check required fields and data formats. Some tools need valid sys_ids from previous steps in the workflow.';
-        }
-        if (errorLower.includes('401') || errorLower.includes('unauthorized')) {
-            return 'AUTHENTICATION EXPIRED: Run "snow-flow auth login" to re-authenticate with ServiceNow.';
-        }
-        if (errorLower.includes('sys_id')) {
-            return 'SYS_ID ERROR: Invalid or missing sys_id in API response. This usually means the record creation failed silently.';
-        }
-        if (errorLower.includes('plugin') || errorLower.includes('license')) {
-            return 'LICENSING ISSUE: Required ServiceNow plugin/license not available. Contact ServiceNow admin for proper licensing.';
-        }
-        return 'UNKNOWN ERROR: Check ServiceNow system logs (System Logs > System Log > All) for detailed error information.';
-    }
-    /**
-     * Enhanced tool execution wrapper with comprehensive feedback
-     */
-    async executeWithFeedback(operationType, operation, details) {
-        try {
-            this.logger.info(`🔄 Executing ${operationType}...`);
-            const startTime = Date.now();
-            const result = await operation();
-            const executionTime = Date.now() - startTime;
-            const validation = await this.validateAndConfirmOperation(operationType, result, details);
-            return {
-                ...validation,
-                execution_time_ms: executionTime,
-                timestamp: new Date().toISOString()
-            };
-        }
-        catch (error) {
-            this.logger.error(`❌ ${operationType} failed:`, error);
-            return {
-                success: false,
-                operation_type: operationType,
-                error: error instanceof Error ? error.message : String(error),
-                suggestion: this.getErrorSuggestion(String(error)),
-                validation_result: 'EXECUTION_ERROR',
-                timestamp: new Date().toISOString()
-            };
-        }
-    }
     /**
      * Validate workspace configuration (fix from user feedback)
      */
@@ -4202,9 +3441,32 @@ ${configList}${layoutsText}${offlineText}
         return errors;
     }
     async run() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-        this.logger.info('ServiceNow Flow/Workspace/Mobile MCP Server running on stdio');
+        try {
+            const transport = new stdio_js_1.StdioServerTransport();
+            // Simple timeout protection (prevents hanging)
+            const connectTimeout = setTimeout(() => {
+                this.logger.error('❌ MCP connection timeout after 30 seconds');
+                process.exit(1);
+            }, 30000);
+            await this.server.connect(transport);
+            clearTimeout(connectTimeout);
+            this.logger.info('✅ ServiceNow Flow/Workspace/Mobile MCP Server running on stdio');
+            // Simple keep-alive (prevents disconnects)
+            setInterval(() => {
+                this.logger.debug('💚 MCP server alive - uptime: ' + Math.round((Date.now() - Date.now()) / 60000) + 'min');
+            }, 120000); // Every 2 minutes
+        }
+        catch (error) {
+            this.logger.error('❌ MCP server failed to start:', error);
+            // Simple retry once
+            this.logger.info('🔄 Retrying MCP connection once...');
+            setTimeout(() => {
+                this.run().catch(() => {
+                    this.logger.error('💥 MCP retry failed - exiting');
+                    process.exit(1);
+                });
+            }, 3000);
+        }
     }
 }
 const server = new ServiceNowFlowWorkspaceMobileMCP();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "4.5.51",
+  "version": "4.5.53",
   "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 245+ ServiceNow tools including complete UX + Agent Workspace creation with official APIs.",
   "main": "dist/index.js",
   "type": "commonjs",