snow-flow 1.3.21 → 1.3.23

package/dist/mcp/servicenow-deployment-mcp.js

@@ -789,6 +789,56 @@ class ServiceNowDeploymentMCP {
                     };
                     let troubleshootingSteps = '';
                     if (is403Error(directError) || is403Error(tableError)) {
+                        // CRITICAL FIX: Check if widget was actually created despite 403 error
+                        this.logger.info('403 error detected, verifying if widget was actually created...');
+                        const verificationResult = await this.verifyWidgetInServiceNow(args.name);
+                        if (verificationResult.exists) {
+                            // Widget was created successfully despite 403 error!
+                            this.logger.info('🎉 Widget verification SUCCESS: Widget exists despite 403 error', {
+                                widgetName: args.name,
+                                sys_id: verificationResult.sys_id,
+                                completenessScore: verificationResult.completenessScore
+                            });
+                            // Format successful response similar to normal deployment
+                            const credentials = await this.oauth.loadCredentials();
+                            const widgetUrl = credentials?.instance ?
+                                `https://${credentials.instance}/sp_config?id=widget_editor&sys_id=${verificationResult.sys_id}` :
+                                'ServiceNow instance URL not available';
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `✅ Widget deployed successfully! (Despite 403 error)
+              
+🎯 Widget Details:
+- Name: ${args.name}
+- Title: ${verificationResult.title || args.title}
+- Sys ID: ${verificationResult.sys_id}
+- Deployment Method: ${deploymentMethod} (with error recovery)
+- Verification: ✅ Confirmed (${verificationResult.completenessScore}/100 complete)
+
+📦 Update Set:
+- Name: ${updateSetName}
+- ID: ${updateSetId || 'None'}
+- Status: ${updateSetId ? '✅ Tracked' : '⚠️ Not tracked'}
+
+🔗 Direct Links:
+- Widget Editor: ${widgetUrl}
+- Service Portal Designer: https://${credentials?.instance}/sp_config?id=designer
+
+🔧 Note: Widget was created successfully despite receiving a 403 error. This is a known issue with ServiceNow permissions that has been automatically resolved.
+
+⚡ **Ready for Testing**
+Your widget has been deployed and is ready for testing in Service Portal.`
+                                    }
+                                ]
+                            };
+                        }
+                        // Widget was NOT created, continue with error handling
+                        this.logger.warn('Widget verification failed: Widget does not exist after deployment attempts', {
+                            widgetName: args.name,
+                            verificationDetails: verificationResult.debugInfo
+                        });
                         // Run authentication diagnostics automatically on 403 errors
                         this.logger.info('403 error detected, running automatic authentication diagnostics...');
                         let diagnosticsResult = '';
@@ -2079,15 +2129,44 @@ ${sessionSummary.statusCounts.pending > 0 ? '- 📋 Complete pending deployments
             if (!data || typeof data !== 'object') {
                 throw new Error('Invalid diagnostics data received from ServiceNow');
             }
-            // Format test results
-            const testResults = Object.entries(tests).map(([name, result]) => `**${name}:** ${result?.status || 'Unknown'}
-  - ${result?.description || 'No description'}
-  ${result?.error ? `- Error: ${result.error}` : ''}
-  ${result?.http_status ? `- HTTP Status: ${result.http_status}` : ''}`).join('\n\n');
-            // Format recommendations
-            const recommendationText = args.include_recommendations !== false && recommendations.length > 0
-                ? `\n\n**🔧 Troubleshooting Recommendations:**\n${recommendations.map((rec) => `- ${rec}`).join('\n')}`
-                : '';
+            // Format test results with enhanced null safety
+            let testResults = 'No test results available';
+            if (tests && typeof tests === 'object') {
+                try {
+                    const entries = Object.entries(tests);
+                    if (entries.length > 0) {
+                        testResults = entries.map(([name, result]) => {
+                            // CRITICAL: Extra null checks for each property
+                            const status = result?.status || 'Unknown';
+                            const description = result?.description || 'No description';
+                            const error = result?.error && typeof result.error === 'string' ? `- Error: ${result.error}` : '';
+                            const httpStatus = result?.http_status && typeof result.http_status === 'number' ? `- HTTP Status: ${result.http_status}` : '';
+                            return `**${name}:** ${status}
+  - ${description}
+  ${error}
+  ${httpStatus}`;
+                        }).join('\n\n');
+                    }
+                }
+                catch (testFormatError) {
+                    this.logger.error('Error formatting test results:', testFormatError);
+                    testResults = '❌ Error formatting test results - check ServiceNow connection';
+                }
+            }
+            // Format recommendations with null safety
+            let recommendationText = '';
+            if (args.include_recommendations !== false && Array.isArray(recommendations) && recommendations.length > 0) {
+                try {
+                    const validRecommendations = recommendations.filter(rec => rec && typeof rec === 'string');
+                    if (validRecommendations.length > 0) {
+                        recommendationText = `\n\n**🔧 Troubleshooting Recommendations:**\n${validRecommendations.map((rec) => `- ${rec}`).join('\n')}`;
+                    }
+                }
+                catch (recFormatError) {
+                    this.logger.error('Error formatting recommendations:', recFormatError);
+                    recommendationText = '\n\n**🔧 Troubleshooting Recommendations:**\n- Unable to format recommendations due to error';
+                }
+            }
             // Generate URL fix recommendation if we detect the trailing slash issue
             const urlFixRecommendation = data.instance_url && typeof data.instance_url === 'string' && data.instance_url.includes('//')
                 ? '\n\n**🚨 CRITICAL URL ISSUE DETECTED:**\n- Your SNOW_INSTANCE in .env has a trailing slash\n- This causes malformed URLs like https://instance.com//api/\n- Remove the trailing slash from SNOW_INSTANCE=your-instance.com/'
@@ -5506,6 +5585,176 @@ Use individual deployment tools like \`snow_deploy_${args.type}\` with manual co
 
 **Error Details**: ${error.message || error}`;
     }
+    /**
+     * Verify widget exists in ServiceNow with comprehensive retry logic
+     * Addresses the critical false negative bug where widgets show 403 errors but are actually created
+     */
+    async verifyWidgetInServiceNow(widgetName) {
+        const maxRetries = 5;
+        const baseDelay = 2000; // Start with 2 seconds
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Progressive delay - ServiceNow needs time to process
+                if (attempt > 1) {
+                    const delay = baseDelay * attempt; // 2s, 4s, 6s, 8s, 10s
+                    this.logger.info(`Waiting ${delay}ms before widget verification attempt ${attempt}/${maxRetries}`);
+                    await this.sleep(delay);
+                }
+                this.logger.info(`Widget verification attempt ${attempt}/${maxRetries}`, { widgetName });
+                // Multi-table verification approach (similar to flow verification)
+                const [mainWidgetCheck, widgetSearchCheck] = await Promise.allSettled([
+                    // Check 1: Direct sp_widget table search by name
+                    this.client.searchRecords('sp_widget', `name=${widgetName}`, 1),
+                    // Check 2: Broader search with ID field
+                    this.client.searchRecords('sp_widget', `name=${widgetName}^ORid=${widgetName}`, 5)
+                ]);
+                let mainWidget = null;
+                let searchResults = null;
+                let verificationDetails = {
+                    attempt,
+                    mainWidgetCheck: 'pending',
+                    widgetSearchCheck: 'pending',
+                    totalFound: 0
+                };
+                // Process main widget check
+                if (mainWidgetCheck.status === 'fulfilled' && mainWidgetCheck.value.success) {
+                    mainWidget = mainWidgetCheck.value.data?.[0];
+                    verificationDetails.mainWidgetCheck = mainWidget ? 'found' : 'not_found';
+                    verificationDetails.totalFound = mainWidgetCheck.value.data?.length || 0;
+                }
+                else {
+                    verificationDetails.mainWidgetCheck = `failed: ${mainWidgetCheck.status === 'rejected' ? mainWidgetCheck.reason : 'unknown error'}`;
+                }
+                // Process widget search check
+                if (widgetSearchCheck.status === 'fulfilled' && widgetSearchCheck.value.success) {
+                    searchResults = widgetSearchCheck.value.data || [];
+                    verificationDetails.widgetSearchCheck = `found_${searchResults.length}`;
+                    // Use search results if main check didn't find anything
+                    if (!mainWidget && searchResults.length > 0) {
+                        mainWidget = searchResults[0];
+                        verificationDetails.totalFound = searchResults.length;
+                    }
+                }
+                else {
+                    verificationDetails.widgetSearchCheck = `failed: ${widgetSearchCheck.status === 'rejected' ? widgetSearchCheck.reason : 'unknown error'}`;
+                }
+                // Calculate completeness score
+                let completenessScore = 0;
+                if (mainWidget) {
+                    completenessScore += mainWidget.sys_id ? 25 : 0;
+                    completenessScore += mainWidget.name ? 25 : 0;
+                    completenessScore += mainWidget.title ? 25 : 0;
+                    completenessScore += mainWidget.template ? 25 : 0;
+                }
+                if (mainWidget && completenessScore >= 75) {
+                    // Widget found and appears complete
+                    this.logger.info(`✅ Widget verification SUCCESS on attempt ${attempt}`, {
+                        widgetName,
+                        sys_id: mainWidget.sys_id,
+                        completenessScore,
+                        totalRetries: attempt
+                    });
+                    return {
+                        exists: true,
+                        sys_id: mainWidget.sys_id,
+                        name: mainWidget.name,
+                        title: mainWidget.title,
+                        completenessScore,
+                        attempt,
+                        verificationDetails,
+                        debugInfo: {
+                            foundVia: verificationDetails.mainWidgetCheck === 'found' ? 'main_check' : 'search_check',
+                            totalFound: verificationDetails.totalFound,
+                            retriesNeeded: attempt
+                        }
+                    };
+                }
+                else if (mainWidget && completenessScore < 75) {
+                    // Widget found but incomplete - might still be processing
+                    this.logger.warn(`⚠️ Widget found but incomplete on attempt ${attempt}`, {
+                        widgetName,
+                        sys_id: mainWidget.sys_id,
+                        completenessScore,
+                        remainingRetries: maxRetries - attempt
+                    });
+                    if (attempt === maxRetries) {
+                        // Last attempt - return what we have
+                        return {
+                            exists: true,
+                            sys_id: mainWidget.sys_id,
+                            name: mainWidget.name,
+                            title: mainWidget.title,
+                            completenessScore,
+                            attempt,
+                            verificationDetails,
+                            debugInfo: {
+                                warning: 'Widget exists but appears incomplete',
+                                foundVia: verificationDetails.mainWidgetCheck === 'found' ? 'main_check' : 'search_check',
+                                totalFound: verificationDetails.totalFound,
+                                retriesNeeded: attempt
+                            }
+                        };
+                    }
+                }
+                else {
+                    // Widget not found
+                    this.logger.warn(`❌ Widget not found on attempt ${attempt}`, {
+                        widgetName,
+                        verificationDetails,
+                        remainingRetries: maxRetries - attempt
+                    });
+                    if (attempt === maxRetries) {
+                        // Final attempt failed
+                        return {
+                            exists: false,
+                            attempt,
+                            verificationDetails,
+                            debugInfo: {
+                                finalAttempt: true,
+                                allChecks: {
+                                    mainWidgetCheck: verificationDetails.mainWidgetCheck,
+                                    widgetSearchCheck: verificationDetails.widgetSearchCheck
+                                },
+                                totalRetries: maxRetries
+                            }
+                        };
+                    }
+                }
+            }
+            catch (verificationError) {
+                this.logger.error(`Widget verification attempt ${attempt} failed`, {
+                    widgetName,
+                    error: verificationError instanceof Error ? verificationError.message : String(verificationError),
+                    remainingRetries: maxRetries - attempt
+                });
+                if (attempt === maxRetries) {
+                    // Final attempt - return failure with error details
+                    return {
+                        exists: false,
+                        attempt,
+                        error: verificationError instanceof Error ? verificationError.message : String(verificationError),
+                        debugInfo: {
+                            finalAttempt: true,
+                            verificationError: true,
+                            totalRetries: maxRetries
+                        }
+                    };
+                }
+            }
+        }
+        // Should not reach here, but safety fallback
+        return {
+            exists: false,
+            attempt: maxRetries,
+            debugInfo: { unexpectedFallback: true }
+        };
+    }
+    /**
+     * Sleep utility for retry delays
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
     /**
      * Format successful deployment response
      */

package/dist/mcp/servicenow-flow-composer-mcp.js

@@ -352,17 +352,36 @@ class ServiceNowFlowComposerMCP {
                     console.log('✅ XML generated:', xmlResult.filePath);
                     // Auto-deploy with fallback strategies
                     const deployResult = await this.deployWithFallback(xmlResult.filePath, flowDefinition);
-                    // Verify deployment was successful
-                    const flowExists = await this.verifyFlowInServiceNow(parsedIntent.flowName);
-                    if (!flowExists) {
-                        throw new Error('Flow deployment claimed success but flow not found in ServiceNow');
+                    // Comprehensive deployment verification
+                    const verification = await this.verifyFlowInServiceNow(parsedIntent.flowName);
+                    if (!verification.verified) {
+                        // Deployment claimed success but flow not found - this is the critical bug!
+                        const errorMsg = `Flow deployment reported success but verification failed: ${verification.reason}`;
+                        // Log detailed verification results for debugging
+                        this.logger.error('CRITICAL: False positive deployment detected', {
+                            flowName: parsedIntent.flowName,
+                            verificationAttempts: verification.attempts,
+                            partialResults: verification.partial_results,
+                            searchQuery: verification.search_query,
+                            error: verification.error
+                        });
+                        throw new Error(errorMsg);
                     }
+                    // Success with comprehensive verification
                     deploymentResult = {
                         success: true,
                         method: deployResult.strategy,
                         xml_file: xmlResult.filePath,
                         message: `✅ Flow deployed via ${deployResult.strategy} and verified in ServiceNow!`,
-                        flow_sys_id: flowExists.sys_id
+                        flow_sys_id: verification.sys_id,
+                        flow_url: verification.url,
+                        verification_score: verification.completeness_score,
+                        verification_details: {
+                            has_flow: true,
+                            has_snapshot: verification.has_snapshot,
+                            has_trigger: verification.has_trigger,
+                            attempts_needed: verification.verification_attempt
+                        }
                     };
                 }
                 catch (xmlError) {
@@ -1987,30 +2006,136 @@ ${categoryFilteredResults.length === 0 ? `🔍 **No templates found matching you
         return mapping[activityType.toLowerCase()] || 'script';
     }
     /**
-     * Verify flow exists in ServiceNow after deployment
+     * Comprehensive flow verification with retry logic
      */
     async verifyFlowInServiceNow(flowName) {
-        try {
-            const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
-            const client = new ServiceNowClient();
-            // Check if flow exists in sys_hub_flow
-            const flowCheck = await client.makeRequest({
-                method: 'GET',
-                url: '/api/now/table/sys_hub_flow',
-                params: {
-                    sysparm_query: `name=${flowName}`,
-                    sysparm_limit: 1
+        const maxRetries = 5;
+        const baseDelay = 2000; // Start with 2 seconds
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Progressive delay - ServiceNow needs time to process
+                if (attempt > 1) {
+                    const delay = baseDelay * attempt; // 2s, 4s, 6s, 8s, 10s
+                    this.logger.info(`Waiting ${delay}ms before verification attempt ${attempt}/${maxRetries}`);
+                    await this.sleep(delay);
+                }
+                const ServiceNowClient = (await Promise.resolve().then(() => __importStar(require('../utils/servicenow-client.js')))).ServiceNowClient;
+                const client = new ServiceNowClient();
+                // Multi-table verification for comprehensive check
+                const verificationPromises = [
+                    // Check main flow table
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_flow',
+                        params: {
+                            sysparm_query: `name=${flowName}^ORsys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,name,sys_name,active,table,description',
+                            sysparm_limit: 5
+                        }
+                    }),
+                    // Check flow snapshots
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_flow_snapshot',
+                        params: {
+                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,flow,name,active',
+                            sysparm_limit: 5
+                        }
+                    }),
+                    // Check trigger instances
+                    client.makeRequest({
+                        method: 'GET',
+                        url: '/api/now/table/sys_hub_trigger_instance',
+                        params: {
+                            sysparm_query: `flow.name=${flowName}^ORflow.sys_name=${flowName}`,
+                            sysparm_fields: 'sys_id,flow,trigger_type',
+                            sysparm_limit: 5
+                        }
+                    })
+                ];
+                const [flowCheck, snapshotCheck, triggerCheck] = await Promise.allSettled(verificationPromises);
+                // Analyze results
+                const flowExists = flowCheck.status === 'fulfilled' &&
+                    flowCheck.value.result &&
+                    flowCheck.value.result.length > 0;
+                const snapshotExists = snapshotCheck.status === 'fulfilled' &&
+                    snapshotCheck.value.result &&
+                    snapshotCheck.value.result.length > 0;
+                const triggerExists = triggerCheck.status === 'fulfilled' &&
+                    triggerCheck.value.result &&
+                    triggerCheck.value.result.length > 0;
+                // Comprehensive verification result
+                if (flowExists) {
+                    const flowData = flowCheck.value.result[0];
+                    return {
+                        verified: true,
+                        sys_id: flowData.sys_id,
+                        name: flowData.name || flowData.sys_name,
+                        active: flowData.active,
+                        table: flowData.table,
+                        has_snapshot: snapshotExists,
+                        has_trigger: triggerExists,
+                        verification_attempt: attempt,
+                        verification_method: 'multi_table_comprehensive',
+                        completeness_score: (flowExists ? 1 : 0) + (snapshotExists ? 1 : 0) + (triggerExists ? 1 : 0),
+                        url: `https://${await this.getInstanceUrl()}/flow-designer/flow/${flowData.sys_id}`
+                    };
+                }
+                // Log partial results for debugging
+                this.logger.warn(`Verification attempt ${attempt}: Flow=${flowExists}, Snapshot=${snapshotExists}, Trigger=${triggerExists}`);
+                // If this is the last attempt, return detailed failure info
+                if (attempt === maxRetries) {
+                    return {
+                        verified: false,
+                        reason: 'Flow not found after comprehensive verification',
+                        attempts: maxRetries,
+                        partial_results: {
+                            flow_found: flowExists,
+                            snapshot_found: snapshotExists,
+                            trigger_found: triggerExists
+                        },
+                        search_query: `name=${flowName}`,
+                        recommendation: 'Check ServiceNow Flow Designer manually or verify deployment was successful'
+                    };
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Verification attempt ${attempt} failed:`, error);
+                // If this is the last attempt, include error details
+                if (attempt === maxRetries) {
+                    return {
+                        verified: false,
+                        reason: 'Verification failed due to error',
+                        error: error instanceof Error ? error.message : String(error),
+                        attempts: maxRetries
+                    };
                 }
-            });
-            if (flowCheck.result && flowCheck.result.length > 0) {
-                return flowCheck.result[0];
             }
-            return null;
         }
-        catch (error) {
-            this.logger.error('Failed to verify flow:', error);
-            return null;
+        return {
+            verified: false,
+            reason: 'Max verification attempts exceeded',
+            attempts: maxRetries
+        };
+    }
+    /**
+     * Helper to get instance URL for flow links
+     */
+    async getInstanceUrl() {
+        try {
+            const credentials = await this.oauth.loadCredentials();
+            return credentials?.instance || 'your-instance.service-now.com';
         }
+        catch {
+            return 'your-instance.service-now.com';
+        }
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
     /**
      * Generate manual import guide for failed deployments

package/dist/memory/memory-client.js

@@ -43,15 +43,43 @@ class MemoryClient {
         await this.operations.setContext(this.sessionId, options.key, options.value, this.agentId, options.expires, options.permissions);
     }
     /**
-     * Retrieve data from shared context
+     * Retrieve data from shared context with agent isolation
      */
     async retrieve(options) {
-        const context = await this.operations.getContext(this.sessionId, options.key);
+        // CRITICAL FIX: Pass agent ID for proper memory isolation
+        const context = await this.operations.getContext(this.sessionId, options.key, this.agentId);
         if (!context) {
             return options.defaultValue !== undefined ? options.defaultValue : null;
         }
         return context.context_value;
     }
+    /**
+     * Retrieve data from truly shared context (no agent isolation)
+     * Use this when agents need to access shared coordination data
+     */
+    async retrieveShared(options) {
+        // Try shared prefix first
+        const sharedKey = `__shared__::${options.key}`;
+        let context = await this.operations.getContext(this.sessionId, sharedKey);
+        // Fallback to original key for backward compatibility
+        if (!context) {
+            context = await this.operations.getContext(this.sessionId, options.key);
+        }
+        if (!context) {
+            return options.defaultValue !== undefined ? options.defaultValue : null;
+        }
+        return context.context_value;
+    }
+    /**
+     * Store data in truly shared context (no agent isolation)
+     * Use this when you want all agents to access the same data
+     */
+    async storeShared(options) {
+        // Use a special shared prefix to avoid conflicts with namespaced keys
+        const sharedKey = `__shared__::${options.key}`;
+        await this.operations.setContext(this.sessionId, sharedKey, options.value, this.agentId, // Still track who created it
+        options.expires, options.permissions);
+    }
     /**
      * Get all context for current session
      */

package/dist/memory/memory-operations.js

@@ -278,23 +278,49 @@ class MemoryOperations {
     }
     // ==================== Shared Context Operations ====================
     /**
-     * Store shared context
+     * Create agent-specific namespaced key for memory isolation
+     * This prevents agents from overwriting each other's memory within the same session
+     */
+    createNamespacedKey(context_key, agent_id) {
+        // Use a delimiter that's unlikely to conflict with normal keys
+        return `${agent_id}::${context_key}`;
+    }
+    /**
+     * Parse namespaced key to extract original key and agent ID
+     */
+    parseNamespacedKey(namespaced_key) {
+        const parts = namespaced_key.split('::');
+        if (parts.length === 2) {
+            return { agent_id: parts[0], original_key: parts[1] };
+        }
+        return { agent_id: null, original_key: namespaced_key };
+    }
+    /**
+     * Store shared context with agent isolation
      */
     async setContext(session_id, context_key, context_value, created_by_agent, expires_at, access_permissions) {
         try {
+            // CRITICAL FIX: Create agent-specific namespace for the context key
+            // This ensures agents don't overwrite each other's memory
+            const namespacedKey = this.createNamespacedKey(context_key, created_by_agent);
             this.memory.run(`
         INSERT OR REPLACE INTO shared_context 
         (session_id, context_key, context_value, created_by_agent, expires_at, access_permissions)
         VALUES (?, ?, ?, ?, ?, ?)
       `, [
                 session_id,
-                context_key,
+                namespacedKey,
                 typeof context_value === 'string' ? context_value : JSON.stringify(context_value),
                 created_by_agent,
                 expires_at ? expires_at.toISOString() : null,
                 access_permissions ? JSON.stringify(access_permissions) : null
             ]);
-            this.logger.debug('Context stored', { session_id, context_key, created_by_agent });
+            this.logger.debug('Context stored with agent isolation', {
+                session_id,
+                original_key: context_key,
+                namespaced_key: namespacedKey,
+                created_by_agent
+            });
         }
         catch (error) {
             this.logger.error('Failed to store context', error);
@@ -302,18 +328,43 @@ class MemoryOperations {
         }
     }
     /**
-     * Get shared context
+     * Get shared context with agent isolation support
      */
-    async getContext(session_id, context_key) {
-        const result = this.memory.get(`
-      SELECT * FROM shared_context 
-      WHERE session_id = ? AND context_key = ?
-        AND (expires_at IS NULL OR expires_at > datetime('now'))
-    `, [session_id, context_key]);
+    async getContext(session_id, context_key, requesting_agent) {
+        // CRITICAL FIX: Try to get agent-specific namespaced key first
+        let result = null;
+        if (requesting_agent) {
+            const namespacedKey = this.createNamespacedKey(context_key, requesting_agent);
+            result = this.memory.get(`
+        SELECT * FROM shared_context 
+        WHERE session_id = ? AND context_key = ?
+          AND (expires_at IS NULL OR expires_at > datetime('now'))
+      `, [session_id, namespacedKey]);
+            this.logger.debug('Attempting namespaced context retrieval', {
+                session_id,
+                original_key: context_key,
+                namespaced_key: namespacedKey,
+                requesting_agent,
+                found: !!result
+            });
+        }
+        // Fallback: Try to get the original key for backward compatibility or shared data
+        if (!result) {
+            result = this.memory.get(`
+        SELECT * FROM shared_context 
+        WHERE session_id = ? AND context_key = ?
+          AND (expires_at IS NULL OR expires_at > datetime('now'))
+      `, [session_id, context_key]);
+            this.logger.debug('Fallback context retrieval', {
+                session_id,
+                context_key,
+                found: !!result
+            });
+        }
         if (result) {
             try {
                 // Try to parse JSON values
-                if (result.context_value && result.context_value.startsWith('{') || result.context_value.startsWith('[')) {
+                if (result.context_value && (result.context_value.startsWith('{') || result.context_value.startsWith('['))) {
                     result.context_value = JSON.parse(result.context_value);
                 }
                 if (result.access_permissions) {
@@ -322,6 +373,7 @@ class MemoryOperations {
             }
             catch (e) {
                 // If parsing fails, return as-is
+                this.logger.warn('Failed to parse stored JSON context', { context_key, error: e });
             }
         }
         return result;

package/dist/utils/servicenow-client.js

@@ -38,17 +38,27 @@ class ServiceNowClient {
             const method = (config.method || 'GET').toLowerCase();
             const url = config.url || config.endpoint;
             const data = config.data || config.body;
+            // CRITICAL FIX: Properly merge headers to allow content-type overrides for XML requests
+            const requestConfig = {
+                ...config,
+                headers: {
+                    ...this.client.defaults.headers.common,
+                    ...this.client.defaults.headers[method],
+                    ...config.headers // This ensures custom headers (like Content-Type: application/xml) override defaults
+                }
+            };
+            this.logger.debug('🔧 Final request config headers:', requestConfig.headers);
             switch (method) {
                 case 'get':
-                    return this.client.get(url, { params: config.params, ...config });
+                    return this.client.get(url, { params: config.params, ...requestConfig });
                 case 'post':
-                    return this.client.post(url, data, config);
+                    return this.client.post(url, data, requestConfig);
                 case 'put':
-                    return this.client.put(url, data, config);
+                    return this.client.put(url, data, requestConfig);
                 case 'patch':
-                    return this.client.patch(url, data, config);
+                    return this.client.patch(url, data, requestConfig);
                 case 'delete':
-                    return this.client.delete(url, config);
+                    return this.client.delete(url, requestConfig);
                 default:
                     throw new Error(`Unsupported HTTP method: ${method}`);
             }
@@ -289,9 +299,19 @@ class ServiceNowClient {
                     };
                     try {
                         const createResponse = await this.client.post(`${this.getBaseUrl()}/api/now/table/sp_widget`, testWidget);
+                        // CRITICAL FIX: Add null safety for response processing
+                        if (!createResponse || !createResponse.data || !createResponse.data.result || !createResponse.data.result.sys_id) {
+                            throw new Error('Widget creation succeeded but response structure is unexpected - unable to verify sys_id');
+                        }
                         const sys_id = createResponse.data.result.sys_id;
-                        // Immediately delete the test widget
-                        await this.client.delete(`${this.getBaseUrl()}/api/now/table/sp_widget/${sys_id}`);
+                        // Immediately delete the test widget with error handling
+                        try {
+                            await this.client.delete(`${this.getBaseUrl()}/api/now/table/sp_widget/${sys_id}`);
+                        }
+                        catch (deleteError) {
+                            this.logger.warn(`Test widget created but cleanup failed: ${deleteError instanceof Error ? deleteError.message : String(deleteError)}`);
+                            // Don't fail the test just because cleanup failed
+                        }
                         return { success: true, data: { message: 'Widget write permissions confirmed' } };
                     }
                     catch (error) {
@@ -304,7 +324,19 @@ class ServiceNowClient {
                 description: 'Check user roles and permissions',
                 test: async () => {
                     const response = await this.client.get(`${this.getBaseUrl()}/api/now/table/sys_user_role?sysparm_query=user=javascript:gs.getUserID()`);
-                    return { success: true, data: { roles: response.data.result.map((r) => r.role?.display_value || r.role) } };
+                    // CRITICAL FIX: Add null safety for response processing
+                    if (!response || !response.data || !response.data.result) {
+                        return { success: true, data: { roles: [], warning: 'Unable to retrieve user roles - response structure unexpected' } };
+                    }
+                    // Safely process roles with null checks
+                    const roles = Array.isArray(response.data.result)
+                        ? response.data.result.map((r) => {
+                            if (!r || typeof r !== 'object')
+                                return 'Unknown Role';
+                            return r.role?.display_value || r.role || 'Unknown Role';
+                        }).filter(role => role && role !== 'Unknown Role')
+                        : [];
+                    return { success: true, data: { roles } };
                 }
             }
         ];
@@ -330,17 +362,27 @@ class ServiceNowClient {
                 };
             }
         }
-        // Analyze results
-        const failedTests = Object.values(diagnostics.tests).filter((test) => test.status.includes('FAIL'));
-        const passedTests = Object.values(diagnostics.tests).filter((test) => test.status.includes('PASS'));
+        // Analyze results with null safety
+        const failedTests = diagnostics.tests && typeof diagnostics.tests === 'object'
+            ? Object.values(diagnostics.tests).filter((test) => test && test.status && test.status.includes('FAIL'))
+            : [];
+        const passedTests = diagnostics.tests && typeof diagnostics.tests === 'object'
+            ? Object.values(diagnostics.tests).filter((test) => test && test.status && test.status.includes('PASS'))
+            : [];
         diagnostics.summary = {
-            total_tests: tests.length,
-            passed: passedTests.length,
-            failed: failedTests.length,
-            overall_status: failedTests.length === 0 ? '✅ ALL SYSTEMS GO' : '⚠️ ISSUES DETECTED'
+            total_tests: tests.length || 0,
+            passed: passedTests.length || 0,
+            failed: failedTests.length || 0,
+            overall_status: failedTests.length === 0 && passedTests.length > 0 ? '✅ ALL SYSTEMS GO' : '⚠️ ISSUES DETECTED'
         };
-        // Generate recommendations
-        diagnostics.recommendations = this.generateAuthRecommendations(diagnostics.tests);
+        // Generate recommendations with null safety
+        try {
+            diagnostics.recommendations = this.generateAuthRecommendations(diagnostics.tests);
+        }
+        catch (recError) {
+            this.logger.error('Error generating recommendations:', recError);
+            diagnostics.recommendations = ['⚠️ Unable to generate recommendations due to error'];
+        }
         return {
             success: failedTests.length === 0,
             data: diagnostics,
@@ -359,24 +401,51 @@ class ServiceNowClient {
      */
     generateAuthRecommendations(tests) {
         const recommendations = [];
-        if (tests['Widget Write Test']?.status.includes('FAIL')) {
-            const error = tests['Widget Write Test'].error;
-            if (error.includes('403')) {
-                recommendations.push('🔐 Widget deployment failed with 403 Forbidden. Check OAuth scopes: ensure \'useraccount\' and \'glide_system_administration\' scopes are enabled');
-                recommendations.push('👤 Verify user has sp_portal_manager or admin role in ServiceNow');
-                recommendations.push('🛡️ Check if instance has deployment restrictions for external applications');
+        // CRITICAL FIX: Add comprehensive null safety checks
+        if (!tests || typeof tests !== 'object') {
+            recommendations.push('⚠️ Unable to analyze test results due to missing test data');
+            return recommendations;
+        }
+        // Safe check for Widget Write Test
+        const widgetTest = tests['Widget Write Test'];
+        if (widgetTest?.status && typeof widgetTest.status === 'string' && widgetTest.status.includes('FAIL')) {
+            const error = widgetTest.error;
+            if (error && typeof error === 'string') {
+                if (error.includes('403')) {
+                    recommendations.push('🔐 Widget deployment failed with 403 Forbidden. Check OAuth scopes: ensure \'useraccount\' and \'glide_system_administration\' scopes are enabled');
+                    recommendations.push('👤 Verify user has sp_portal_manager or admin role in ServiceNow');
+                    recommendations.push('🛡️ Check if instance has deployment restrictions for external applications');
+                }
+                if (error.includes('401')) {
+                    recommendations.push('🔑 Authentication failed. Re-run: snow-flow auth login');
+                }
             }
-            if (error.includes('401')) {
-                recommendations.push('🔑 Authentication failed. Re-run: snow-flow auth login');
+            else {
+                recommendations.push('🔐 Widget write test failed with unknown error. Check ServiceNow permissions');
             }
         }
-        if (tests['User Role Check']?.status.includes('PASS')) {
-            const roles = tests['User Role Check'].result?.roles || [];
-            if (!roles.some((role) => role.includes('admin') || role.includes('sp_portal'))) {
-                recommendations.push('⚠️ User lacks admin or portal management roles. Contact ServiceNow admin to assign appropriate roles');
+        // Safe check for User Role Check
+        const roleTest = tests['User Role Check'];
+        if (roleTest?.status && typeof roleTest.status === 'string' && roleTest.status.includes('PASS')) {
+            const roles = roleTest.result?.roles;
+            if (Array.isArray(roles)) {
+                const hasRequiredRole = roles.some((role) => {
+                    if (typeof role === 'string') {
+                        return role.includes('admin') || role.includes('sp_portal');
+                    }
+                    return false;
+                });
+                if (!hasRequiredRole) {
+                    recommendations.push('⚠️ User lacks admin or portal management roles. Contact ServiceNow admin to assign appropriate roles');
+                }
+            }
+            else {
+                recommendations.push('⚠️ Unable to verify user roles. Check if user has admin or portal management permissions');
             }
         }
-        if (tests['Update Set Access']?.status.includes('FAIL')) {
+        // Safe check for Update Set Access
+        const updateSetTest = tests['Update Set Access'];
+        if (updateSetTest?.status && typeof updateSetTest.status === 'string' && updateSetTest.status.includes('FAIL')) {
             recommendations.push('📦 Update Set access failed. Ensure user has update_set_manager or admin role');
         }
         if (recommendations.length === 0) {

package/dist/utils/xml-first-flow-generator.js

@@ -102,6 +102,28 @@ class XMLFirstFlowGenerator {
             .replace(/"/g, '"')
             .replace(/'/g, ''');
     }
+    /**
+     * Escape JSON content for XML serialization (no CDATA needed)
+     * CRITICAL FIX: Properly handle JSON content in XML to avoid parsing errors
+     */
+    escapeForXml(jsonContent) {
+        if (!jsonContent)
+            return '';
+        // First escape XML special characters
+        let escaped = jsonContent
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+        // Additional escaping for problematic sequences that could break XML parsing
+        escaped = escaped
+            .replace(/]]>/g, ']]&gt;') // Escape CDATA end sequences
+            .replace(/\r?\n/g, '&#10;') // Preserve line breaks as XML entities
+            .replace(/\r/g, '&#13;') // Preserve carriage returns
+            .replace(/\t/g, '&#9;'); // Preserve tabs
+        return escaped;
+    }
     /**
      * Generate complete Update Set XML for a flow
      * Based on REAL ServiceNow XML structure research
@@ -157,7 +179,7 @@ class XMLFirstFlowGenerator {
     <action>INSERT_OR_UPDATE</action>
     <application>global</application>
     <name>sys_hub_flow_snapshot_${snapshotSysId}</name>
-    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?><record_update table="sys_hub_flow_snapshot"><sys_hub_flow_snapshot action="INSERT_OR_UPDATE"><sys_id>${snapshotSysId}</sys_id><name>${this.escapeXml(flowDef.name)}</name><flow>${this.flowSysId}</flow><note>Initial version</note><snapshot><![CDATA[${JSON.stringify(flowDefinitionJson, null, 2)}]]]]><![CDATA[></snapshot><sys_created_by>admin</sys_created_by><sys_created_on>${timestamp}</sys_created_on></sys_hub_flow_snapshot></record_update>]]></payload>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?><record_update table="sys_hub_flow_snapshot"><sys_hub_flow_snapshot action="INSERT_OR_UPDATE"><sys_id>${snapshotSysId}</sys_id><name>${this.escapeXml(flowDef.name)}</name><flow>${this.flowSysId}</flow><note>Initial version</note><snapshot>${this.escapeForXml(JSON.stringify(flowDefinitionJson, null, 2))}</snapshot><sys_created_by>admin</sys_created_by><sys_created_on>${timestamp}</sys_created_on></sys_hub_flow_snapshot></record_update>]]></payload>
     <remote_update_set>${updateSetSysId}</remote_update_set>
     <source_table>sys_hub_flow_snapshot</source_table>
     <type>Flow Designer Snapshot</type>
@@ -339,7 +361,7 @@ class XMLFirstFlowGenerator {
     <action>INSERT_OR_UPDATE</action>
     <application>global</application>
     <name>sys_hub_action_instance_${sysIds[index]}</name>
-    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?><record_update table="sys_hub_action_instance"><sys_hub_action_instance action="INSERT_OR_UPDATE"><sys_id>${sysIds[index]}</sys_id><flow>${this.flowSysId}</flow><action_type display_value="">${this.getActionTypeId(activity.type)}</action_type><name>${this.escapeXml(activity.name)}</name><order>${activity.order || (index + 1) * 100}</order><active>true</active><inputs><![CDATA[${JSON.stringify(activity.inputs)}]]]]><![CDATA[></inputs><outputs><![CDATA[${JSON.stringify(activity.outputs || {})}]]]]><![CDATA[></outputs><condition>${this.escapeXml(activity.condition || '')}</condition><comment_text/><sys_class_name>sys_hub_action_instance</sys_class_name><sys_created_by>admin</sys_created_by><sys_created_on>${timestamp}</sys_created_on><sys_domain>global</sys_domain><sys_domain_path>/</sys_domain_path></sys_hub_action_instance></record_update>]]></payload>
+    <payload><![CDATA[<?xml version="1.0" encoding="UTF-8"?><record_update table="sys_hub_action_instance"><sys_hub_action_instance action="INSERT_OR_UPDATE"><sys_id>${sysIds[index]}</sys_id><flow>${this.flowSysId}</flow><action_type display_value="">${this.getActionTypeId(activity.type)}</action_type><name>${this.escapeXml(activity.name)}</name><order>${activity.order || (index + 1) * 100}</order><active>true</active><inputs>${this.escapeForXml(JSON.stringify(activity.inputs))}</inputs><outputs>${this.escapeForXml(JSON.stringify(activity.outputs || {}))}</outputs><condition>${this.escapeXml(activity.condition || '')}</condition><comment_text/><sys_class_name>sys_hub_action_instance</sys_class_name><sys_created_by>admin</sys_created_by><sys_created_on>${timestamp}</sys_created_on><sys_domain>global</sys_domain><sys_domain_path>/</sys_domain_path></sys_hub_action_instance></record_update>]]></payload>
     <remote_update_set>${updateSetSysId}</remote_update_set>
     <source_table>sys_hub_action_instance</source_table>
     <type>Flow Designer Action</type>

package/dist/version.js

@@ -7,7 +7,7 @@ exports.VERSION_INFO = exports.VERSION = void 0;
 exports.getVersionString = getVersionString;
 exports.getLatestFeatures = getLatestFeatures;
 exports.isLatestVersion = isLatestVersion;
-exports.VERSION = '1.3.16';
+exports.VERSION = '1.3.23';
 exports.VERSION_INFO = {
     version: exports.VERSION,
     name: 'Snow-Flow',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.3.21",
+  "version": "1.3.23",
   "description": "ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development inspired by claude-flow. Transform complex workflows into elegant one-command orchestration.",
   "main": "dist/index.js",
   "type": "commonjs",