snow-flow 3.0.10 → 3.0.14

package/dist/utils/anti-mock-data-validator.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * Anti-Mock Data Validator
+ *
+ * This utility ensures NO mock, demo, sample, or fake data is ever used in any MCP tools.
+ * All data must come from real ServiceNow instances.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataReport = exports.checkDataIntegrity = exports.validateRealData = exports.antiMockValidator = exports.AntiMockDataValidator = void 0;
+const logger_js_1 = require("./logger.js");
+class AntiMockDataValidator {
+    constructor() {
+        // Patterns that indicate mock/demo/test data
+        this.MOCK_DATA_PATTERNS = [
+            // Explicit mock indicators
+            /\bmock\b/i,
+            /\bdemo\b/i,
+            /\bsample\b/i,
+            /\btest\b/i,
+            /\bfake\b/i,
+            /\bplaceholder\b/i,
+            /\bdummy\b/i,
+            /\bexample\b/i,
+            // Common test values
+            /^test$/i,
+            /^demo$/i,
+            /test.*user/i,
+            /demo.*user/i,
+            /sample.*data/i,
+            /example.*com/i,
+            /test@test\.com/i,
+            /demo@demo\.com/i,
+            // Sequential test patterns
+            /test\d+/i,
+            /demo\d+/i,
+            /user\d+$/i,
+            /item\d+$/i,
+            // Placeholder values
+            /^n\/a$/i,
+            /^tbd$/i,
+            /^to.*be.*determined/i,
+            /^pending$/i,
+            /^xxx+$/i,
+            /^temp/i,
+            // Mock ServiceNow patterns
+            /^INC\d{7}000\d+$/, // Sequential incident numbers indicating test data
+            /^CHG\d{7}000\d+$/, // Sequential change numbers indicating test data
+            /^PRB\d{7}000\d+$/, // Sequential problem numbers indicating test data
+        ];
+        // Suspicious numeric patterns that might indicate generated/mock data
+        this.SUSPICIOUS_NUMERIC_PATTERNS = [
+            /^123+$/, // 123, 1234, 12345...
+            /^999+$/, // 999, 9999, 99999...
+            /^111+$/, // 111, 1111, 11111...
+            /^000+$/, // 000, 0000, 00000...
+            /^(12){2,}$/, // 121212...
+            /^(99){2,}$/, // 999999...
+        ];
+        this.logger = new logger_js_1.Logger('AntiMockDataValidator');
+    }
+    /**
+     * Validate that dataset contains only real ServiceNow data
+     */
+    validateDataset(data, source = 'unknown') {
+        if (!data || data.length === 0) {
+            return {
+                isValid: false,
+                violations: ['Empty dataset - no real data to validate'],
+                suspiciousFields: [],
+                suspiciousValues: []
+            };
+        }
+        const violations = [];
+        const suspiciousFields = [];
+        const suspiciousValues = [];
+        // Check each record
+        data.forEach((record, index) => {
+            if (!record || typeof record !== 'object') {
+                violations.push(`Record ${index}: Invalid record structure`);
+                return;
+            }
+            // Check each field in the record
+            Object.entries(record).forEach(([field, value]) => {
+                const fieldViolations = this.validateFieldValue(field, value, source);
+                if (fieldViolations.length > 0) {
+                    violations.push(`Record ${index}, Field '${field}': ${fieldViolations.join(', ')}`);
+                    if (!suspiciousFields.includes(field)) {
+                        suspiciousFields.push(field);
+                    }
+                    if (!suspiciousValues.includes(value)) {
+                        suspiciousValues.push(value);
+                    }
+                }
+            });
+        });
+        // Additional dataset-level checks
+        const datasetViolations = this.validateDatasetPatterns(data, source);
+        violations.push(...datasetViolations);
+        return {
+            isValid: violations.length === 0,
+            violations,
+            suspiciousFields,
+            suspiciousValues
+        };
+    }
+    /**
+     * Validate individual field value
+     */
+    validateFieldValue(field, value, source) {
+        const violations = [];
+        if (value === null || value === undefined) {
+            return violations; // Null values are acceptable
+        }
+        const stringValue = String(value);
+        // Check for mock data patterns
+        for (const pattern of this.MOCK_DATA_PATTERNS) {
+            if (pattern.test(stringValue)) {
+                violations.push(`Matches mock data pattern: ${pattern.source}`);
+            }
+        }
+        // Check numeric patterns for suspicious sequences
+        if (typeof value === 'number' || /^\d+$/.test(stringValue)) {
+            for (const pattern of this.SUSPICIOUS_NUMERIC_PATTERNS) {
+                if (pattern.test(stringValue)) {
+                    violations.push(`Suspicious numeric pattern: ${stringValue}`);
+                }
+            }
+        }
+        // Field-specific validation
+        if (field.toLowerCase().includes('email') && stringValue.includes('@')) {
+            if (/@(test|demo|example|mock|fake)\.(com|org|net)$/i.test(stringValue)) {
+                violations.push('Test/demo email domain detected');
+            }
+        }
+        if (field.toLowerCase().includes('name') || field.toLowerCase().includes('user')) {
+            if (/^(test|demo|sample|mock|fake|admin|user)\d*$/i.test(stringValue)) {
+                violations.push('Generic test/demo name pattern');
+            }
+        }
+        return violations;
+    }
+    /**
+     * Validate patterns across the entire dataset
+     */
+    validateDatasetPatterns(data, source) {
+        const violations = [];
+        // Check for suspiciously uniform data
+        if (data.length > 10) {
+            const firstRecord = data[0];
+            const identicalCount = data.filter(record => JSON.stringify(record) === JSON.stringify(firstRecord)).length;
+            if (identicalCount > data.length * 0.8) {
+                violations.push('Dataset appears to have too many identical records (possible mock data)');
+            }
+        }
+        // Check for sequential IDs indicating generated data
+        const sysIds = data.map(record => record.sys_id).filter(id => id);
+        if (sysIds.length > 5) {
+            const sequentialCount = this.countSequentialIds(sysIds);
+            if (sequentialCount > sysIds.length * 0.7) {
+                violations.push('Too many sequential sys_id values (indicates generated test data)');
+            }
+        }
+        // Check creation dates for suspicious patterns
+        const createdDates = data.map(record => record.sys_created_on).filter(date => date);
+        if (createdDates.length > 5) {
+            const simultaneousCreations = this.countSimultaneousCreations(createdDates);
+            if (simultaneousCreations > createdDates.length * 0.8) {
+                violations.push('Too many records created simultaneously (indicates bulk test data creation)');
+            }
+        }
+        return violations;
+    }
+    /**
+     * Count sequential sys_id patterns
+     */
+    countSequentialIds(sysIds) {
+        let sequentialCount = 0;
+        const sortedIds = sysIds.sort();
+        for (let i = 1; i < sortedIds.length; i++) {
+            const current = sortedIds[i];
+            const previous = sortedIds[i - 1];
+            // Check if IDs follow a sequential pattern
+            if (this.areIdsSequential(previous, current)) {
+                sequentialCount++;
+            }
+        }
+        return sequentialCount;
+    }
+    /**
+     * Check if two sys_ids are sequential
+     */
+    areIdsSequential(id1, id2) {
+        if (id1.length !== id2.length)
+            return false;
+        if (id1.length !== 32)
+            return false; // ServiceNow sys_ids are 32 chars
+        // Convert hex to numbers and check if they're sequential
+        try {
+            const num1 = parseInt(id1.slice(-8), 16);
+            const num2 = parseInt(id2.slice(-8), 16);
+            return Math.abs(num2 - num1) === 1;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Count records created at exactly the same time
+     */
+    countSimultaneousCreations(dates) {
+        const dateMap = new Map();
+        dates.forEach(date => {
+            const normalizedDate = new Date(date).toISOString();
+            dateMap.set(normalizedDate, (dateMap.get(normalizedDate) || 0) + 1);
+        });
+        let simultaneousCount = 0;
+        dateMap.forEach(count => {
+            if (count > 1) {
+                simultaneousCount += count;
+            }
+        });
+        return simultaneousCount;
+    }
+    /**
+     * Perform comprehensive data integrity check
+     */
+    performDataIntegrityCheck(data, source = 'unknown') {
+        const validation = this.validateDataset(data, source);
+        let qualityScore = 100;
+        // Deduct points for violations
+        qualityScore -= validation.violations.length * 10;
+        qualityScore -= validation.suspiciousFields.length * 5;
+        qualityScore -= validation.suspiciousValues.length * 2;
+        // Ensure score doesn't go below 0
+        qualityScore = Math.max(0, qualityScore);
+        return {
+            hasRealData: validation.isValid && qualityScore > 70,
+            dataQualityScore: qualityScore,
+            mockDataDetected: !validation.isValid,
+            details: [
+                `Validation result: ${validation.isValid ? 'PASSED' : 'FAILED'}`,
+                `Total violations: ${validation.violations.length}`,
+                `Suspicious fields: ${validation.suspiciousFields.length}`,
+                `Data quality score: ${qualityScore}/100`,
+                `Source: ${source}`,
+                ...validation.violations.slice(0, 5) // Show first 5 violations
+            ]
+        };
+    }
+    /**
+     * Enforce zero tolerance policy for mock data
+     */
+    enforceZeroTolerancePolicy(data, source = 'unknown') {
+        const validation = this.validateDataset(data, source);
+        if (!validation.isValid) {
+            const errorMessage = [
+                '🚨 MOCK DATA DETECTED - ZERO TOLERANCE POLICY VIOLATED!',
+                `Source: ${source}`,
+                `Violations found: ${validation.violations.length}`,
+                '',
+                'Violations:',
+                ...validation.violations.slice(0, 10),
+                '',
+                '❌ This operation has been BLOCKED.',
+                '✅ Only REAL ServiceNow data is allowed.',
+                '',
+                'Please verify your data source and try again with actual ServiceNow records.'
+            ].join('\n');
+            this.logger.error(errorMessage);
+            throw new Error(`Mock data detected in ${source}. Only real ServiceNow data allowed.`);
+        }
+        this.logger.info(`✅ Data validation passed for ${source} - ${data.length} real records confirmed`);
+    }
+    /**
+     * Generate validation report
+     */
+    generateValidationReport(data, source = 'unknown') {
+        const integrityCheck = this.performDataIntegrityCheck(data, source);
+        return [
+            '🔥 ANTI-MOCK DATA VALIDATION REPORT',
+            '='.repeat(50),
+            `📊 Source: ${source}`,
+            `📈 Records Analyzed: ${data.length}`,
+            `🎯 Data Quality Score: ${integrityCheck.dataQualityScore}/100`,
+            `✅ Real Data Status: ${integrityCheck.hasRealData ? 'CONFIRMED' : 'SUSPICIOUS'}`,
+            `🚨 Mock Data Detected: ${integrityCheck.mockDataDetected ? 'YES - BLOCKED' : 'NO - SAFE'}`,
+            '',
+            '📝 Details:',
+            ...integrityCheck.details.map(detail => `  - ${detail}`),
+            '',
+            integrityCheck.hasRealData
+                ? '🎉 VALIDATION PASSED - Real ServiceNow data confirmed!'
+                : '❌ VALIDATION FAILED - Suspicious data patterns detected!',
+            '',
+            '🔐 Zero Mock Data Policy: ENFORCED',
+            '📋 Only 100% real ServiceNow data allowed'
+        ].join('\n');
+    }
+}
+exports.AntiMockDataValidator = AntiMockDataValidator;
+// Export singleton instance
+exports.antiMockValidator = new AntiMockDataValidator();
+// Export validation utilities for use in MCP servers
+const validateRealData = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.enforceZeroTolerancePolicy(data, source);
+};
+exports.validateRealData = validateRealData;
+const checkDataIntegrity = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.performDataIntegrityCheck(data, source);
+};
+exports.checkDataIntegrity = checkDataIntegrity;
+const generateDataReport = (data, source = 'MCP Operation') => {
+    return exports.antiMockValidator.generateValidationReport(data, source);
+};
+exports.generateDataReport = generateDataReport;
+//# sourceMappingURL=anti-mock-data-validator.js.map

package/dist/utils/servicenow-eventual-consistency.d.ts

@@ -0,0 +1,120 @@
+/**
+ * ServiceNow Eventual Consistency Handler
+ *
+ * ServiceNow uses a distributed database architecture with eventual consistency:
+ * - Write operations go to primary database (immediate)
+ * - Read operations may use read replicas (1-3 second lag)
+ * - This causes race conditions in deployment verification
+ */
+import { ServiceNowClient } from './servicenow-client.js';
+export interface RetryConfig {
+    maxRetries?: number;
+    baseDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+export interface VerificationResult {
+    success: boolean;
+    attempts: number;
+    finalAttemptError?: any;
+    isLikelyTimingIssue: boolean;
+}
+export declare class ServiceNowEventualConsistency {
+    private logger;
+    constructor(loggerName?: string);
+    /**
+     * Retry a ServiceNow operation with exponential backoff
+     * Designed specifically for post-deployment verification
+     */
+    retryWithBackoff<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<{
+        result: T | null;
+        success: boolean;
+        attempts: number;
+    }>;
+    /**
+     * Verify a ServiceNow record exists with retry logic
+     */
+    verifyRecordExists(client: ServiceNowClient, table: string, sys_id: string, config?: RetryConfig): Promise<VerificationResult>;
+    /**
+     * Verify multiple records exist (batch verification)
+     */
+    verifyMultipleRecords(client: ServiceNowClient, verifications: Array<{
+        table: string;
+        sys_id: string;
+        name?: string;
+    }>, config?: RetryConfig): Promise<Array<VerificationResult & {
+        table: string;
+        sys_id: string;
+        name?: string;
+    }>>;
+    /**
+     * Execute operation with eventual consistency retry
+     * Generic wrapper for any ServiceNow operation that might fail due to timing
+     */
+    executeWithRetry<T>(operationName: string, operation: () => Promise<T>, validator: (result: T) => boolean, config?: RetryConfig): Promise<{
+        result: T | null;
+        success: boolean;
+        metadata: any;
+    }>;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    /**
+     * Determine if an error indicates a permanent failure vs timing issue
+     */
+    private isPermanentError;
+    /**
+     * Get user-friendly error description
+     */
+    private getErrorDescription;
+    /**
+     * Assess if failure is likely due to timing issues
+     */
+    private assessIfTimingIssue;
+    /**
+     * Create a pre-configured instance for widget deployments
+     */
+    static createForWidgets(): ServiceNowEventualConsistency;
+    /**
+     * Create a pre-configured instance for flow deployments
+     */
+    static createForFlows(): ServiceNowEventualConsistency;
+    /**
+     * Create a pre-configured instance for application deployments
+     */
+    static createForApplications(): ServiceNowEventualConsistency;
+}
+/**
+ * Default configuration for different deployment types
+ */
+export declare const CONSISTENCY_CONFIGS: {
+    WIDGET: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    FLOW: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    APPLICATION: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+    BATCH: {
+        maxRetries: number;
+        baseDelay: number;
+        maxDelay: number;
+        backoffMultiplier: number;
+    };
+};
+export declare const widgetConsistency: ServiceNowEventualConsistency;
+export declare const flowConsistency: ServiceNowEventualConsistency;
+export declare const appConsistency: ServiceNowEventualConsistency;
+//# sourceMappingURL=servicenow-eventual-consistency.d.ts.map

package/dist/utils/servicenow-eventual-consistency.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * ServiceNow Eventual Consistency Handler
+ *
+ * ServiceNow uses a distributed database architecture with eventual consistency:
+ * - Write operations go to primary database (immediate)
+ * - Read operations may use read replicas (1-3 second lag)
+ * - This causes race conditions in deployment verification
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appConsistency = exports.flowConsistency = exports.widgetConsistency = exports.CONSISTENCY_CONFIGS = exports.ServiceNowEventualConsistency = void 0;
+const logger_js_1 = require("./logger.js");
+class ServiceNowEventualConsistency {
+    constructor(loggerName = 'EventualConsistency') {
+        this.logger = new logger_js_1.Logger(loggerName);
+    }
+    /**
+     * Retry a ServiceNow operation with exponential backoff
+     * Designed specifically for post-deployment verification
+     */
+    async retryWithBackoff(operation, config = {}) {
+        const { maxRetries = 5, baseDelay = 1000, maxDelay = 8000, backoffMultiplier = 1.5 } = config;
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+                    this.logger.info(`⏳ Retry attempt ${attempt + 1}/${maxRetries} (waiting ${delay}ms for consistency)`);
+                    await this.sleep(delay);
+                }
+                const result = await operation();
+                if (result) {
+                    this.logger.info(`✅ Operation succeeded on attempt ${attempt + 1}`);
+                    return { result, success: true, attempts: attempt + 1 };
+                }
+            }
+            catch (error) {
+                lastError = error;
+                if (this.isPermanentError(error)) {
+                    this.logger.error(`❌ Permanent error detected:`, error);
+                    return { result: null, success: false, attempts: attempt + 1 };
+                }
+                if (attempt === 0) {
+                    this.logger.info(`⏳ ${this.getErrorDescription(error)} - typical ServiceNow consistency issue`);
+                }
+                else {
+                    this.logger.info(`⏳ Still getting ${error.status || 'error'}, retrying...`);
+                }
+            }
+        }
+        this.logger.warn(`⚠️ Operation failed after ${maxRetries} attempts`);
+        this.logger.warn(`⚠️ Last error: ${lastError?.message || 'Unknown'}`);
+        return { result: null, success: false, attempts: maxRetries };
+    }
+    /**
+     * Verify a ServiceNow record exists with retry logic
+     */
+    async verifyRecordExists(client, table, sys_id, config = {}) {
+        this.logger.info(`🔍 Verifying ${table} record ${sys_id} (handling eventual consistency)`);
+        const operation = async () => {
+            const response = await client.getRecord(table, sys_id);
+            return response && response.sys_id === sys_id ? response : null;
+        };
+        const { result, success, attempts } = await this.retryWithBackoff(operation, config);
+        if (!success) {
+            const isLikelyTimingIssue = this.assessIfTimingIssue(attempts, config.maxRetries);
+            if (isLikelyTimingIssue) {
+                this.logger.warn(`⚠️ This appears to be a ServiceNow consistency issue, not a deployment failure`);
+                this.logger.warn(`⚠️ Check directly: /${table}.do?sys_id=${sys_id}`);
+            }
+            return {
+                success: false,
+                attempts,
+                isLikelyTimingIssue
+            };
+        }
+        return {
+            success: true,
+            attempts,
+            isLikelyTimingIssue: false
+        };
+    }
+    /**
+     * Verify multiple records exist (batch verification)
+     */
+    async verifyMultipleRecords(client, verifications, config = {}) {
+        const results = [];
+        for (const verification of verifications) {
+            const result = await this.verifyRecordExists(client, verification.table, verification.sys_id, config);
+            results.push({
+                ...result,
+                table: verification.table,
+                sys_id: verification.sys_id,
+                name: verification.name
+            });
+            // Small delay between verifications to avoid rate limiting
+            if (verifications.length > 1) {
+                await this.sleep(200);
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute operation with eventual consistency retry
+     * Generic wrapper for any ServiceNow operation that might fail due to timing
+     */
+    async executeWithRetry(operationName, operation, validator, config = {}) {
+        this.logger.info(`🚀 Executing ${operationName} with consistency handling`);
+        const { result, success, attempts } = await this.retryWithBackoff(async () => {
+            const opResult = await operation();
+            return validator(opResult) ? opResult : null;
+        }, config);
+        return {
+            result,
+            success,
+            metadata: {
+                operationName,
+                attempts,
+                isLikelyTimingIssue: !success && this.assessIfTimingIssue(attempts, config.maxRetries)
+            }
+        };
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Determine if an error indicates a permanent failure vs timing issue
+     */
+    isPermanentError(error) {
+        // Permanent errors that shouldn't be retried
+        if (error.status === 401)
+            return true; // Authentication
+        if (error.status === 400 && !error.message?.includes('null'))
+            return true; // Bad request
+        if (error.message?.includes('table does not exist'))
+            return true; // Invalid table
+        if (error.message?.includes('permission denied') && error.status !== 403)
+            return true; // Real permission issues
+        return false;
+    }
+    /**
+     * Get user-friendly error description
+     */
+    getErrorDescription(error) {
+        if (error.status === 403)
+            return 'Access temporarily denied (403)';
+        if (error.status === 404)
+            return 'Record not found (404)';
+        if (error.message?.includes('null'))
+            return 'Null response received';
+        return `Error ${error.status || 'unknown'}`;
+    }
+    /**
+     * Assess if failure is likely due to timing issues
+     */
+    assessIfTimingIssue(attempts, maxRetries = 5) {
+        // If we exhausted all retries and got timing-related errors, it's likely a timing issue
+        return attempts >= maxRetries;
+    }
+    /**
+     * Create a pre-configured instance for widget deployments
+     */
+    static createForWidgets() {
+        return new ServiceNowEventualConsistency('WidgetConsistency');
+    }
+    /**
+     * Create a pre-configured instance for flow deployments
+     */
+    static createForFlows() {
+        return new ServiceNowEventualConsistency('FlowConsistency');
+    }
+    /**
+     * Create a pre-configured instance for application deployments
+     */
+    static createForApplications() {
+        return new ServiceNowEventualConsistency('AppConsistency');
+    }
+}
+exports.ServiceNowEventualConsistency = ServiceNowEventualConsistency;
+/**
+ * Default configuration for different deployment types
+ */
+exports.CONSISTENCY_CONFIGS = {
+    // Fast retry for simple records
+    WIDGET: {
+        maxRetries: 5,
+        baseDelay: 800,
+        maxDelay: 6000,
+        backoffMultiplier: 1.4
+    },
+    // Medium retry for complex records
+    FLOW: {
+        maxRetries: 6,
+        baseDelay: 1200,
+        maxDelay: 8000,
+        backoffMultiplier: 1.5
+    },
+    // Longer retry for applications with dependencies
+    APPLICATION: {
+        maxRetries: 8,
+        baseDelay: 1500,
+        maxDelay: 12000,
+        backoffMultiplier: 1.6
+    },
+    // Quick check for batch operations
+    BATCH: {
+        maxRetries: 3,
+        baseDelay: 500,
+        maxDelay: 3000,
+        backoffMultiplier: 1.3
+    }
+};
+// Export singleton instances
+exports.widgetConsistency = ServiceNowEventualConsistency.createForWidgets();
+exports.flowConsistency = ServiceNowEventualConsistency.createForFlows();
+exports.appConsistency = ServiceNowEventualConsistency.createForApplications();
+//# sourceMappingURL=servicenow-eventual-consistency.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.0.10",
-  "description": "Snow-Flow v3.0.10: REPORTING & DASHBOARD FIXES! Complete overhaul of reporting and dashboard MCPs. Fixed dashboard visibility in ServiceNow (now uses pa_dashboards, sys_portal_page with intelligent fallback). Reports now properly fetch data with correct field configuration. KPIs and Performance Analytics work correctly. All dashboard and report creation tools now functional with proper ServiceNow API integration. Plus all previous features: Codespaces support, Claude Code integration, 100+ MCP tools.",
+  "version": "3.0.14",
+  "description": "Snow-Flow v3.0.14: WRITE PERMISSIONS FIX! 🔧 Fixed 'this.client.create is not a function' error that was blocking all deployments. Corrected API method calls to use createRecord/deleteRecord. Write permissions diagnostic now works correctly. Plus all features: Zero Mock Data Guarantee, race condition fixes, intelligent reporting, and 100+ MCP tools.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {
@@ -358,7 +358,8 @@
   "mcpCapabilities": {
     "realApiIntegration": true,
     "noMockData": true,
-    "mockDataNote": "NO MOCK DATA - All ML operations require real ServiceNow PA/PI licenses",
+    "mockDataNote": "🔥 ZERO MOCK DATA GUARANTEE - All reports, dashboards, and analytics use 100% REAL ServiceNow data from your actual instance. NO demo/sample/test data ever used.",
+    "reportingDataPolicy": "ALL LIVE DATA - Every report, dashboard, chart, and KPI populated exclusively with real records from your ServiceNow tables",
     "productionReady": true,
     "batchOptimization": true,
     "intelligentAnalysis": true,