snow-flow 4.5.45 → 4.5.47

package/CLAUDE.md

@@ -684,23 +684,47 @@ Snow-Flow now automatically sets its Update Set as the user's current Update Set
 - `snow_get_flow_details` - Get detailed flow configuration
 - `snow_import_flow_from_xml` - Import flows from XML (only programmatic creation method)
 
-**Configurable Agent Workspace Tools (UX App Architecture):**
-- `snow_create_workspace` - Create Configurable Agent Workspaces using UX App architecture (sys_ux_app_route, sys_ux_screen_type, sys_ux_screen, sys_ux_macroponent)
-- `snow_discover_workspaces` - Find all Configurable Workspaces
+**🏗️ COMPLETE UX WORKSPACE CREATION (6-Step Workflow):**
+
+**CRITICAL:** Use the correct 6-step workflow for creating functional workspaces. This is the ONLY way to create workspaces that actually work!
+
+**Step 1: Experience Record (sys_ux_experience)**
+- `snow_create_ux_experience` - Create the top-level workspace container
+- Required fields: `name`, auto-detects `root_macroponent` (x_snc_app_shell_uib_app_shell)
+
+**Step 2: App Configuration (sys_ux_app_config)**
+- `snow_create_ux_app_config` - Create workspace settings linked to experience
+- Required fields: `name`, `experience_sys_id` (from Step 1)
+
+**Step 3: Page Macroponent (sys_ux_macroponent)**
+- `snow_create_ux_page_macroponent` - Define actual page content
+- Required fields: `name`, defaults to `sn-canvas-panel` root component
+- Optional: `composition` JSON for custom layouts
+
+**Step 4: Page Registry (sys_ux_page_registry)**
+- `snow_create_ux_page_registry` - Register page within workspace
+- Required fields: `sys_name` (technical name), `app_config_sys_id`, `macroponent_sys_id`
+
+**Step 5: Route Record (sys_ux_app_route)**
+- `snow_create_ux_app_route` - Create URL routing to page
+- Required fields: `name` (URL slug), `app_config_sys_id`, `page_sys_name`
+
+**Step 6: Landing Page Update**
+- `snow_update_ux_app_config_landing_page` - Set default landing page
+- Required fields: `app_config_sys_id`, `route_name`
+
+**COMPLETE WORKFLOW TOOL:**
+- `snow_create_complete_workspace` - **RECOMMENDED:** Executes all 6 steps automatically
+- Creates: Experience → App Config → Page Macroponent → Page Registry → Route → Landing Page
+- Only requires: `workspace_name`, optional: `description`, `home_page_name`, `route_name`
 
-**🏗️ CONFIGURABLE WORKSPACE ARCHITECTURE:**
-Based on ServiceNow's official Configurable Agent Workspace structure:
-- **App Route** → `sys_ux_app_route` (top-level workspace routing)
-- **Screen Collection** → `sys_ux_screen_type` (groups of related screens)  
-- **Individual Screens** → `sys_ux_screen` (specific workspace screens)
-- **Screen Components** → `sys_ux_macroponent` (components within screens)
 
 **Mobile App Tools:**
 - `snow_configure_mobile_app` - Configure mobile applications
 - `snow_send_push_notification` - Send push notifications
 - `snow_configure_offline_sync` - Configure offline sync
 
-**🆕 COMPLETE UI BUILDER INTEGRATION (15 NEW TOOLS!):**
+**🆕 COMPLETE UI BUILDER INTEGRATION (22 TOOLS!):**
 
 **UI Builder Page Management (sys_ux_page):**
 - `snow_create_uib_page` - Create UI Builder pages with automatic routing

package/README.md

@@ -5,10 +5,15 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/node/v/snow-flow.svg?style=for-the-badge&logo=node.js&color=339933)](https://nodejs.org)
 
-**Talk to your ServiceNow instance through Claude Code • 20+ MCP Servers • 200+ ServiceNow Tools • Multi-Agent Orchestration**
+**Talk to your ServiceNow instance through Claude Code • 20+ MCP Servers • 240+ ServiceNow Tools • Complete UX Workspace Creation • Multi-Agent Orchestration**
 
 ---
 
+TO FIX TEMP CLAUDE CODE INK ERROR, RUN BEFORE SWARM COMMAND: 
+```bash
+npm install -g @anthropic-ai/claude-code@1.0.95 --save-exact
+```
+
 ## What is Snow-Flow?
 
 Snow-Flow is a conversational ServiceNow development platform that bridges Claude Code with ServiceNow through specialized MCP (Model Context Protocol) servers. Instead of navigating ServiceNow's web interface, you develop through natural conversation with Claude Code, which orchestrates multi-agent workflows to handle complex ServiceNow operations.
@@ -310,4 +315,4 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ---
 
-**Snow-Flow: Conversational ServiceNow development through Claude Code.**
+**Snow-Flow: Conversational ServiceNow development through Claude Code.**

package/dist/cli.js

@@ -416,7 +416,7 @@ program
                 cliLogger.info('\n🔗 Live ServiceNow integration: ❌ Disabled');
             }
         }
-        console.log(chalk_1.default.blue('\n🚀 Starting Claude Code with 235+ ServiceNow tools...'));
+        console.log(chalk_1.default.blue('\n🚀 Starting Claude Code with 240+ ServiceNow tools including complete UX Workspace creation...'));
         // Try to execute Claude Code directly with the prompt
         const success = await executeClaudeCode(orchestrationPrompt);
         if (success) {
@@ -524,7 +524,7 @@ async function executeClaudeCode(prompt) {
                     console.log(chalk_1.default.green(`✅ All ${newStatus.running} ServiceNow MCP servers ready`));
                 }
                 else {
-                    console.log(chalk_1.default.green(`✅ All ${systemStatus.running} ServiceNow MCP servers ready (235+ tools)`));
+                    console.log(chalk_1.default.green(`✅ All ${systemStatus.running} ServiceNow MCP servers ready (240+ tools with UX Workspace workflow)`));
                 }
             }
             catch (error) {
@@ -704,6 +704,7 @@ The Queen Agent will automatically discover and validate table schemas based on
 **Table Detection Examples:**
 - "create widget for incident records" → Discovers: incident, sys_user, sys_user_group
 - "build approval flow for u_equipment_request" → Discovers: u_equipment_request, sys_user, sysapproval_approver
+- "create UX workspace for IT support" → Discovers: sys_ux_experience, sys_ux_app_config, sys_ux_macroponent, sys_ux_page_registry, sys_ux_app_route
 - "portal showing catalog items" → Discovers: sc_cat_item, sc_category, sc_request
 - "dashboard with CMDB assets" → Discovers: cmdb_ci, cmdb_rel_ci, sys_user
 - "report on problem tickets" → Discovers: problem, incident, sys_user
@@ -716,6 +717,21 @@ The Queen Agent will automatically discover and validate table schemas based on
 
 ## 👑 Your Queen Agent Responsibilities
 
+## 🏗️ UX Workspace Creation Specific Instructions
+If the task involves UX WORKSPACE CREATION (e.g., "create workspace for IT support", "build agent workspace"):
+
+1. **ALWAYS** use \`snow_create_complete_workspace\` for full 6-step workflow
+2. **INDIVIDUAL STEPS** available if fine control needed:
+   - Step 1: \`snow_create_ux_experience\` (sys_ux_experience)
+   - Step 2: \`snow_create_ux_app_config\` (sys_ux_app_config) 
+   - Step 3: \`snow_create_ux_page_macroponent\` (sys_ux_macroponent)
+   - Step 4: \`snow_create_ux_page_registry\` (sys_ux_page_registry)
+   - Step 5: \`snow_create_ux_app_route\` (sys_ux_app_route)
+   - Step 6: \`snow_update_ux_app_config_landing_page\` (landing page route)
+3. **VERIFY ORDER**: Must follow exact sequence for functional workspaces
+4. **STORE SYS_IDS**: Store all sys_ids in Memory for agents coordination
+5. **TEST ACCESS**: Provide workspace URL: \`/now/experience/workspace/{route_name}\`
+
 ## 📊 Data Generation Specific Instructions
 If the task is identified as DATA GENERATION (e.g., "create 5000 incidents"):
 
@@ -1596,7 +1612,7 @@ program
         console.log(chalk_1.default.green.bold('\n✅ Snow-Flow project initialized successfully!'));
         console.log('\n📋 Created Snow-Flow configuration:');
         console.log('   ✓ .claude/ - Claude Code MCP configuration');
-        console.log('   ✓ .mcp.json - 20+ ServiceNow MCP servers (235+ tools)');
+        console.log('   ✓ .mcp.json - 20+ ServiceNow MCP servers (240+ tools including complete UX Workspace workflow)');
         console.log('   ✓ CLAUDE.md - Complete development guide');
         console.log('   ✓ README.md - Current capabilities documentation');
         console.log('   ✓ .snow-flow/ - Project workspace and memory');
@@ -1627,7 +1643,7 @@ program
         console.log('2. Authenticate Snow-Flow: ' + chalk_1.default.cyan('snow-flow auth login'));
         console.log('3. Start developing: ' + chalk_1.default.cyan('snow-flow swarm "create incident dashboard"'));
         console.log('\n📚 Complete documentation: ' + chalk_1.default.blue('https://snow-flow.dev'));
-        console.log('💡 UI Builder, Agent Workspaces, and 235+ tools now available');
+        console.log('💡 Complete 6-step UX Workspace creation, UI Builder, and 240+ tools now available');
         // Force exit to prevent hanging
         process.exit(0);
     }

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

@@ -115,63 +115,109 @@ class ServiceNowFlowWorkspaceMobileMCP {
                         }
                     }
                 },
-                // Agent Workspace Tools
+                // 🏗️ COMPLETE UX WORKSPACE CREATION (6-Step Workflow)
+                // STEP 1: Experience Record (sys_ux_experience)
                 {
-                    name: 'snow_create_workspace',
-                    description: 'Creates a Configurable Agent Workspace using modern UX App architecture (sys_ux_app_route, sys_ux_screen_type, sys_ux_screen, sys_ux_macroponent). Creates complete workspace with routing, screen collections, and components.',
+                    name: 'snow_create_ux_experience',
+                    description: 'STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace. This is the first step in the 6-step workspace creation process.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            name: { type: 'string', description: 'Configurable Workspace name' },
-                            description: { type: 'string', description: 'Workspace description' },
-                            tables: { type: 'array', items: { type: 'string' }, description: 'Tables to create screens for (incident, task, etc.)' },
-                            application: { type: 'string', description: 'Application scope', default: 'global' },
-                            roles: { type: 'array', items: { type: 'string' }, description: 'Roles with workspace access' }
+                            name: { type: 'string', description: 'Experience name (e.g., "My Workspace")' },
+                            root_macroponent: { type: 'string', description: 'Root macroponent sys_id (usually x_snc_app_shell_uib_app_shell, auto-detected if not provided)' },
+                            description: { type: 'string', description: 'Experience description' }
                         },
-                        required: ['name', 'tables']
+                        required: ['name']
                     }
                 },
+                // STEP 2: App Configuration Record (sys_ux_app_config)
                 {
-                    name: 'snow_create_workspace_list',
-                    description: 'Creates a custom list configuration for Agent Workspace.',
+                    name: 'snow_create_ux_app_config',
+                    description: 'STEP 2: Create UX App Configuration Record (sys_ux_app_config) - Contains workspace settings and links to the experience from Step 1.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            workspace: { type: 'string', description: 'Parent workspace' },
-                            name: { type: 'string', description: 'List name' },
-                            table: { type: 'string', description: 'Table for the list' },
-                            filter: { type: 'string', description: 'List filter condition' },
-                            fields: { type: 'array', items: { type: 'string' }, description: 'Fields to display' },
-                            order_by: { type: 'string', description: 'Sort order' },
-                            max_entries: { type: 'number', description: 'Maximum entries', default: 50 }
+                            name: { type: 'string', description: 'App config name (e.g., "My Workspace Config")' },
+                            experience_sys_id: { type: 'string', description: 'Experience sys_id from Step 1' },
+                            description: { type: 'string', description: 'App configuration description' }
                         },
-                        required: ['workspace', 'name', 'table']
+                        required: ['name', 'experience_sys_id']
                     }
                 },
+                // STEP 3: Page Macroponent Record (sys_ux_macroponent)
                 {
-                    name: 'snow_configure_workspace_notifications',
-                    description: 'Configures notification preferences for Agent Workspace.',
+                    name: 'snow_create_ux_page_macroponent',
+                    description: 'STEP 3: Create Page Macroponent Record (sys_ux_macroponent) - Defines the actual page content that will be displayed.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            workspace: { type: 'string', description: 'Workspace sys_id' },
-                            enable_desktop: { type: 'boolean', description: 'Enable desktop notifications' },
-                            enable_sound: { type: 'boolean', description: 'Enable sound alerts' },
-                            notification_types: { type: 'array', items: { type: 'string' }, description: 'Types to notify about' },
-                            priority_threshold: { type: 'number', description: 'Minimum priority for notifications' }
+                            name: { type: 'string', description: 'Page macroponent name (e.g., "My Home Page")' },
+                            root_component: { type: 'string', default: 'sn-canvas-panel', description: 'Root component to render (default: sn-canvas-panel for simple pages)' },
+                            composition: { type: 'object', description: 'JSON layout configuration (default: simple single column)' },
+                            description: { type: 'string', description: 'Page macroponent description' }
                         },
-                        required: ['workspace']
+                        required: ['name']
                     }
                 },
+                // STEP 4: Page Registry Record (sys_ux_page_registry)
                 {
-                    name: 'snow_discover_workspaces',
-                    description: 'Discovers available Agent Workspaces and their configurations.',
+                    name: 'snow_create_ux_page_registry',
+                    description: 'STEP 4: Create Page Registry Record (sys_ux_page_registry) - Registers the page for use within the workspace configuration.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            include_tabs: { type: 'boolean', description: 'Include tab configurations', default: false },
-                            include_lists: { type: 'boolean', description: 'Include list configurations', default: false }
-                        }
+                            sys_name: { type: 'string', description: 'Unique technical name for the page (e.g., "my_home_page")' },
+                            app_config_sys_id: { type: 'string', description: 'App config sys_id from Step 2' },
+                            macroponent_sys_id: { type: 'string', description: 'Macroponent sys_id from Step 3' },
+                            description: { type: 'string', description: 'Page registry description' }
+                        },
+                        required: ['sys_name', 'app_config_sys_id', 'macroponent_sys_id']
+                    }
+                },
+                // STEP 5: Route Record (sys_ux_app_route)
+                {
+                    name: 'snow_create_ux_app_route',
+                    description: 'STEP 5: Create Route Record (sys_ux_app_route) - Defines the URL slug that leads to the page.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Route name - becomes URL slug (e.g., "home")' },
+                            app_config_sys_id: { type: 'string', description: 'App config sys_id from Step 2' },
+                            page_sys_name: { type: 'string', description: 'Page sys_name from Step 4 registry' },
+                            description: { type: 'string', description: 'Route description' }
+                        },
+                        required: ['name', 'app_config_sys_id', 'page_sys_name']
+                    }
+                },
+                // STEP 6: Update App Config with Landing Page
+                {
+                    name: 'snow_update_ux_app_config_landing_page',
+                    description: 'STEP 6: Update App Configuration with Landing Page Route - Sets the default landing page for the workspace.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            app_config_sys_id: { type: 'string', description: 'App config sys_id from Step 2' },
+                            route_name: { type: 'string', description: 'Route name from Step 5' }
+                        },
+                        required: ['app_config_sys_id', 'route_name']
+                    }
+                },
+                // COMPLETE WORKFLOW: All 6 steps in one tool
+                {
+                    name: 'snow_create_complete_workspace',
+                    description: 'Create Complete UX Workspace - Executes all 6 steps automatically: Experience → App Config → Page Macroponent → Page Registry → Route → Landing Page Route. Creates a fully functional workspace.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            workspace_name: { type: 'string', description: 'Workspace name (used for all components)' },
+                            description: { type: 'string', description: 'Workspace description' },
+                            home_page_name: { type: 'string', default: 'home', description: 'Home page name (default: "home")' },
+                            route_name: { type: 'string', default: 'home', description: 'URL route name (default: "home")' },
+                            root_component: { type: 'string', default: 'sn-canvas-panel', description: 'Root component for page' },
+                            composition: { type: 'object', description: 'Custom page layout (optional)' },
+                            root_macroponent: { type: 'string', description: 'Custom root macroponent (auto-detected if not provided)' }
+                        },
+                        required: ['workspace_name']
                     }
                 },
                 // Mobile Tools
@@ -702,12 +748,27 @@ class ServiceNowFlowWorkspaceMobileMCP {
                     case 'snow_import_flow_from_xml':
                         result = await this.importFlowFromXml(args);
                         break;
-                    // Agent Workspace
-                    case 'snow_create_workspace':
-                        result = await this.createWorkspace(args);
+                    // 🏗️ UX WORKSPACE CREATION (6-Step Workflow)
+                    case 'snow_create_ux_experience':
+                        result = await this.snow_create_ux_experience(args);
                         break;
-                    case 'snow_discover_workspaces':
-                        result = await this.discoverWorkspaces(args);
+                    case 'snow_create_ux_app_config':
+                        result = await this.snow_create_ux_app_config(args);
+                        break;
+                    case 'snow_create_ux_page_macroponent':
+                        result = await this.snow_create_ux_page_macroponent(args);
+                        break;
+                    case 'snow_create_ux_page_registry':
+                        result = await this.snow_create_ux_page_registry(args);
+                        break;
+                    case 'snow_create_ux_app_route':
+                        result = await this.snow_create_ux_app_route(args);
+                        break;
+                    case 'snow_update_ux_app_config_landing_page':
+                        result = await this.snow_update_ux_app_config_landing_page(args);
+                        break;
+                    case 'snow_create_complete_workspace':
+                        result = await this.snow_create_complete_workspace(args);
                         break;
                     // Mobile
                     case 'snow_configure_mobile_app':
@@ -1221,101 +1282,6 @@ ${executionList}
             throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to import flow from XML: ${error}`);
         }
     }
-    // Agent Workspace Implementation
-    // Configurable Agent Workspace Implementation (UX App Architecture ONLY)
-    async createWorkspace(args) {
-        try {
-            this.logger.info("Creating Configurable Agent Workspace (UX App Architecture)...");
-            // Generate clean route for UX App
-            const cleanRoute = args.name
-                .toLowerCase()
-                .replace(/[^a-z0-9]/g, "-")
-                .replace(/--+/g, "-")
-                .replace(/^-|-$/g, "")
-                .substring(0, 50);
-            // Step 1: Create UX App Route (MANDATORY)
-            const appRouteData = {
-                route: `/${cleanRoute}`,
-                name: args.name,
-                title: args.name,
-                description: args.description || `Configurable Agent Workspace: ${args.name}`,
-                application: "global",
-                route_type: "workspace",
-                active: true
-            };
-            this.logger.trackAPICall("CREATE", "sys_ux_app_route", 1);
-            const appRouteResponse = await this.client.createRecord("sys_ux_app_route", appRouteData);
-            if (!appRouteResponse.success) {
-                return {
-                    success: false,
-                    error: `UX App Route creation failed: ${appRouteResponse.error}`,
-                    suggestion: "Check UX App permissions and Now Experience Framework licensing."
-                };
-            }
-            return {
-                success: true,
-                workspace_type: "Configurable Agent Workspace (UX App)",
-                app_route: appRouteResponse.data,
-                sys_id: appRouteResponse.data.sys_id,
-                route: `/${cleanRoute}`,
-                message: `Configurable Agent Workspace created successfully`
-            };
-        }
-        catch (error) {
-            this.logger.error("Configurable Workspace creation failed:", error);
-            throw error;
-        }
-    }
-    async discoverWorkspaces(args) {
-        try {
-            this.logger.info('Discovering Agent Workspaces...');
-            // Validate table access first
-            const response = await this.client.searchRecords('sys_ux_app_route', '', 50);
-            if (!response.success) {
-                return {
-                    success: false,
-                    error: 'Cannot access Agent Workspace tables. Agent Workspace plugin may not be installed or activated.',
-                    suggestion: 'Install Agent Workspace plugin in ServiceNow: System Applications → All Available Applications → Agent Workspace'
-                };
-            }
-            const workspaces = response.data.result;
-            if (!workspaces.length) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: '❌ No Agent Workspaces found'
-                        }]
-                };
-            }
-            const workspaceList = await Promise.all(workspaces.map(async (workspace) => {
-                let details = `🖥️ **${workspace.name}**
-🆔 ${workspace.sys_id}
-📝 ${workspace.description || 'No description'}`;
-                if (args.include_tabs) {
-                    const tabsResponse = await this.client.searchRecords('sys_aw_tab', `workspace=${workspace.sys_id}`, 10);
-                    if (tabsResponse.success && tabsResponse.data.result.length) {
-                        const tabs = tabsResponse.data.result.map((t) => `  - ${t.label}`).join('\n');
-                        details += `\n📑 Tabs:\n${tabs}`;
-                    }
-                }
-                return details;
-            }));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `🔍 Discovered Agent Workspaces:
-
-${workspaceList.join('\n\n')}
-
-✨ Found ${workspaces.length} workspace(s)`
-                    }]
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to discover workspaces:', error);
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to discover workspaces: ${error}`);
-        }
-    }
     // Mobile Implementation  
     async configureMobileApp(args) {
         try {
@@ -2609,6 +2575,389 @@ ${configList}${layoutsText}${offlineText}
             throw error;
         }
     }
+    /**
+     * STEP 1: Create Experience Record (sys_ux_experience)
+     * This is the top-level container for the workspace
+     */
+    async snow_create_ux_experience(args) {
+        try {
+            this.logger.info(`Creating UX Experience: ${args.name}`);
+            // Test mode validation - reject fake test data
+            if (args.name && (args.name.toLowerCase().includes('test') || args.name === 'Test Experience')) {
+                return {
+                    success: false,
+                    error: 'Test mode detected. This tool requires a real workspace name.',
+                    suggestion: 'Use a realistic workspace name like "IT Support Workspace" or "Customer Service Hub"',
+                    test_mode: true
+                };
+            }
+            // Find default shell macroponent - usually x_snc_app_shell_uib_app_shell
+            const shellQuery = await this.client.searchRecords('sys_ux_macroponent', 'name=x_snc_app_shell_uib_app_shell');
+            let shellSysId = null;
+            if (shellQuery.success && shellQuery.data.result.length > 0) {
+                shellSysId = shellQuery.data.result[0].sys_id;
+                this.logger.info(`✅ Found app shell macroponent: ${shellSysId}`);
+            }
+            else {
+                this.logger.warn(`⚠️ Default app shell not found, will use provided root_macroponent`);
+                shellSysId = args.root_macroponent || null;
+            }
+            // Create experience record
+            const experienceData = {
+                name: args.name,
+                active: true,
+                root_macroponent: shellSysId,
+                description: args.description || `Experience for ${args.name}`
+            };
+            // Check if UX framework is available
+            const uxCheck = await this.client.searchRecords('sys_ux_experience', '', 1);
+            if (!uxCheck.success) {
+                return {
+                    success: false,
+                    error: 'Now Experience Framework (UXF) is not available in this ServiceNow instance.',
+                    suggestion: 'UX Workspace creation requires the Now Experience Framework plugin. Contact your ServiceNow administrator.',
+                    plugin_required: 'Now Experience Framework (UXF)',
+                    licensing_note: 'UXF may require additional ServiceNow licensing'
+                };
+            }
+            const result = await this.client.createRecord('sys_ux_experience', experienceData);
+            if (result.success && result.data && result.data.result && result.data.result.sys_id) {
+                this.logger.info(`✅ UX Experience created with sys_id: ${result.data.result.sys_id}`);
+                return {
+                    success: true,
+                    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';
+                throw new Error(`Failed to create experience: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to create UX experience:', error);
+            throw error;
+        }
+    }
+    /**
+     * STEP 2: Create App Configuration Record (sys_ux_app_config)
+     * Links to the experience and contains workspace settings
+     */
+    async snow_create_ux_app_config(args) {
+        try {
+            this.logger.info(`Creating UX App Config: ${args.name}`);
+            // Validate experience_sys_id format
+            if (!args.experience_sys_id || args.experience_sys_id.length !== 32) {
+                return {
+                    success: false,
+                    error: `Invalid experience_sys_id: '${args.experience_sys_id}'. Must be a valid 32-character ServiceNow sys_id.`,
+                    suggestion: 'Use the sys_id returned from snow_create_ux_experience (Step 1)',
+                    validation_error: true
+                };
+            }
+            // Validate experience exists
+            const experienceCheck = await this.client.getRecord('sys_ux_experience', args.experience_sys_id);
+            if (!experienceCheck.success) {
+                return {
+                    success: false,
+                    error: `Experience with sys_id ${args.experience_sys_id} not found. Please create the experience first using snow_create_ux_experience.`,
+                    suggestion: 'Run Step 1: snow_create_ux_experience before creating app config'
+                };
+            }
+            // Create app config record
+            const configData = {
+                name: args.name,
+                experience_assoc: args.experience_sys_id, // CRITICAL: Link to experience
+                description: args.description || `App configuration for ${args.name}`,
+                // landing_page_route will be set in Step 6
+            };
+            const result = await this.client.createRecord('sys_ux_app_config', configData);
+            if (result.success && result.data && result.data.result && result.data.result.sys_id) {
+                this.logger.info(`✅ UX App Config created with sys_id: ${result.data.result.sys_id}`);
+                return {
+                    success: true,
+                    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';
+                throw new Error(`Failed to create app config: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to create UX app config:', error);
+            throw error;
+        }
+    }
+    /**
+     * STEP 3: Create Page Macroponent Record (sys_ux_macroponent)
+     * Defines the actual page content that will be displayed
+     */
+    async snow_create_ux_page_macroponent(args) {
+        try {
+            this.logger.info(`Creating UX Page Macroponent: ${args.name}`);
+            // Default composition for empty page
+            const defaultComposition = {
+                layout: {
+                    default: {
+                        "grid-template-columns": "1fr"
+                    }
+                }
+            };
+            // Create macroponent record
+            const macroponentData = {
+                name: args.name,
+                root_component: args.root_component || 'sn-canvas-panel', // Good default for pages
+                composition: JSON.stringify(args.composition || defaultComposition),
+                description: args.description || `Page macroponent for ${args.name}`
+            };
+            const result = await this.client.createRecord('sys_ux_macroponent', macroponentData);
+            if (result.success && result.data && result.data.result && result.data.result.sys_id) {
+                this.logger.info(`✅ UX Page Macroponent created with sys_id: ${result.data.result.sys_id}`);
+                return {
+                    success: true,
+                    macroponent_sys_id: result.data.result.sys_id,
+                    message: `Page Macroponent '${args.name}' created successfully`,
+                    next_step: "Create Page Registry using this macroponent_sys_id and app_config_sys_id"
+                };
+            }
+            else {
+                const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating page macroponent';
+                throw new Error(`Failed to create page macroponent: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to create UX page macroponent:', error);
+            throw error;
+        }
+    }
+    /**
+     * STEP 4: Create Page Registry Record (sys_ux_page_registry)
+     * Registers the page for use within the workspace configuration
+     */
+    async snow_create_ux_page_registry(args) {
+        try {
+            this.logger.info(`Creating UX Page Registry: ${args.sys_name}`);
+            // Validate app config and macroponent exist
+            const configCheck = await this.client.getRecord('sys_ux_app_config', args.app_config_sys_id);
+            if (!configCheck.success) {
+                return {
+                    success: false,
+                    error: `App Config with sys_id ${args.app_config_sys_id} not found. Please create the app config first using snow_create_ux_app_config.`,
+                    suggestion: 'Run Step 2: snow_create_ux_app_config before creating page registry'
+                };
+            }
+            const macroponentCheck = await this.client.getRecord('sys_ux_macroponent', args.macroponent_sys_id);
+            if (!macroponentCheck.success) {
+                return {
+                    success: false,
+                    error: `Macroponent with sys_id ${args.macroponent_sys_id} not found. Please create the macroponent first using snow_create_ux_page_macroponent.`,
+                    suggestion: 'Run Step 3: snow_create_ux_page_macroponent before creating page registry'
+                };
+            }
+            // Create page registry record
+            const registryData = {
+                sys_name: args.sys_name, // Technical name for the page
+                app_config: args.app_config_sys_id,
+                root_macroponent: args.macroponent_sys_id,
+                description: args.description || `Page registry for ${args.sys_name}`
+            };
+            const result = await this.client.createRecord('sys_ux_page_registry', registryData);
+            if (result.success && result.data && result.data.result && result.data.result.sys_id) {
+                this.logger.info(`✅ UX Page Registry created with sys_id: ${result.data.result.sys_id}`);
+                return {
+                    success: true,
+                    page_registry_sys_id: result.data.result.sys_id,
+                    page_sys_name: args.sys_name,
+                    message: `Page Registry '${args.sys_name}' created successfully`,
+                    next_step: "Create Route using this page sys_name and app_config_sys_id"
+                };
+            }
+            else {
+                const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating page registry';
+                throw new Error(`Failed to create page registry: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to create UX page registry:', error);
+            throw error;
+        }
+    }
+    /**
+     * STEP 5: Create Route Record (sys_ux_app_route)
+     * Defines the URL slug that leads to the page
+     */
+    async snow_create_ux_app_route(args) {
+        try {
+            this.logger.info(`Creating UX App Route: ${args.name}`);
+            // Validate app config exists
+            const configCheck = await this.client.getRecord('sys_ux_app_config', args.app_config_sys_id);
+            if (!configCheck.success) {
+                return {
+                    success: false,
+                    error: `App Config with sys_id ${args.app_config_sys_id} not found. Please create the app config first using snow_create_ux_app_config.`,
+                    suggestion: 'Run Step 2: snow_create_ux_app_config before creating route'
+                };
+            }
+            // Create route record
+            const routeData = {
+                name: args.name, // This becomes the URL slug
+                app_config: args.app_config_sys_id,
+                page: args.page_sys_name, // References the sys_name from page registry
+                route_type: 'page',
+                description: args.description || `Route for page ${args.page_sys_name}`
+            };
+            const result = await this.client.createRecord('sys_ux_app_route', routeData);
+            if (result.success && result.data && result.data.result && result.data.result.sys_id) {
+                this.logger.info(`✅ UX App Route created with sys_id: ${result.data.result.sys_id}`);
+                return {
+                    success: true,
+                    route_sys_id: result.data.result.sys_id,
+                    route_name: args.name,
+                    url_slug: args.name,
+                    message: `Route '${args.name}' created successfully`,
+                    next_step: "Update App Configuration with this route as landing_page_route"
+                };
+            }
+            else {
+                const error = (result.data && result.data.error) || (result.error) || 'Unknown error creating app route';
+                throw new Error(`Failed to create app route: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to create UX app route:', error);
+            throw error;
+        }
+    }
+    /**
+     * STEP 6: Update App Configuration with Landing Page Route
+     * Sets the default landing page for the workspace
+     */
+    async snow_update_ux_app_config_landing_page(args) {
+        try {
+            this.logger.info(`Updating App Config landing page: ${args.app_config_sys_id}`);
+            // Update app config with landing page route
+            const updateData = {
+                landing_page_route: args.route_name
+            };
+            const result = await this.client.updateRecord('sys_ux_app_config', args.app_config_sys_id, updateData);
+            if (result.success) {
+                this.logger.info(`✅ App Config updated with landing page route: ${args.route_name}`);
+                return {
+                    success: true,
+                    message: `App Configuration updated with landing page route '${args.route_name}'`,
+                    workspace_complete: true,
+                    summary: "Workspace creation completed successfully - all 6 steps finished"
+                };
+            }
+            else {
+                const error = (result.data && result.data.error) || (result.error) || 'Unknown error updating app config';
+                throw new Error(`Failed to update app config: ${error}`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to update app config landing page:', error);
+            throw error;
+        }
+    }
+    /**
+     * COMPLETE WORKSPACE WORKFLOW: All 6 steps in sequence
+     * Creates a fully functional workspace in the correct order
+     */
+    async snow_create_complete_workspace(args) {
+        try {
+            this.logger.info(`🚀 Starting complete workspace creation: ${args.workspace_name}`);
+            const results = {
+                workspace_name: args.workspace_name,
+                steps_completed: [],
+                sys_ids: {}
+            };
+            // STEP 1: Create Experience
+            const experience = await this.snow_create_ux_experience({
+                name: args.workspace_name,
+                description: args.description || `Complete workspace: ${args.workspace_name}`,
+                root_macroponent: args.root_macroponent
+            });
+            results.steps_completed.push('Experience Created');
+            results.sys_ids.experience_sys_id = experience.experience_sys_id;
+            // STEP 2: Create App Config
+            const appConfig = await this.snow_create_ux_app_config({
+                name: `${args.workspace_name} Config`,
+                experience_sys_id: experience.experience_sys_id,
+                description: `Configuration for ${args.workspace_name}`
+            });
+            results.steps_completed.push('App Configuration Created');
+            results.sys_ids.app_config_sys_id = appConfig.app_config_sys_id;
+            // STEP 3: Create Page Macroponent
+            const homePage = args.home_page_name || 'home';
+            const macroponent = await this.snow_create_ux_page_macroponent({
+                name: `${args.workspace_name} ${homePage} Page`,
+                root_component: args.root_component || 'sn-canvas-panel',
+                composition: args.composition,
+                description: `Home page for ${args.workspace_name}`
+            });
+            results.steps_completed.push('Page Macroponent Created');
+            results.sys_ids.macroponent_sys_id = macroponent.macroponent_sys_id;
+            // STEP 4: Create Page Registry
+            const pageSysName = this.generateTechnicalName(args.workspace_name, homePage);
+            const registry = await this.snow_create_ux_page_registry({
+                sys_name: pageSysName,
+                app_config_sys_id: appConfig.app_config_sys_id,
+                macroponent_sys_id: macroponent.macroponent_sys_id,
+                description: `Registry for ${args.workspace_name} home page`
+            });
+            results.steps_completed.push('Page Registry Created');
+            results.sys_ids.page_registry_sys_id = registry.page_registry_sys_id;
+            // STEP 5: Create Route
+            const routeName = args.route_name || homePage;
+            const route = await this.snow_create_ux_app_route({
+                name: routeName,
+                app_config_sys_id: appConfig.app_config_sys_id,
+                page_sys_name: pageSysName,
+                description: `Route for ${args.workspace_name} ${homePage} page`
+            });
+            results.steps_completed.push('Route Created');
+            results.sys_ids.route_sys_id = route.route_sys_id;
+            // STEP 6: Update App Config with Landing Page
+            await this.snow_update_ux_app_config_landing_page({
+                app_config_sys_id: appConfig.app_config_sys_id,
+                route_name: routeName
+            });
+            results.steps_completed.push('Landing Page Route Set');
+            this.logger.info(`🎉 Complete workspace creation finished successfully!`);
+            return {
+                success: true,
+                workspace_name: args.workspace_name,
+                all_steps_completed: true,
+                steps_completed: results.steps_completed,
+                sys_ids: results.sys_ids,
+                workspace_url: `/now/experience/workspace/${routeName}`,
+                message: `Workspace '${args.workspace_name}' created successfully with all 6 steps completed`,
+                summary: `Experience → App Config → Page Macroponent → Page Registry → Route → Landing Page Route - All connected properly`
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to create complete workspace:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate technical name for pages (consistent formatting)
+     */
+    generateTechnicalName(workspaceName, pageName) {
+        const combined = `${workspaceName}_${pageName}`;
+        return combined
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, '_')
+            .replace(/[^a-z0-9_]/g, '')
+            .replace(/__+/g, '_')
+            .replace(/^_|_$/g, '')
+            .substring(0, 80);
+    }
     /**
      * Generate valid workspace URL from name (fix from user feedback)
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "4.5.45",
-  "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 200+ ServiceNow tools for comprehensive platform development.",
+  "version": "4.5.47",
+  "description": "Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 240+ ServiceNow tools including complete 6-step UX Workspace creation workflow.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {

package/website/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
     <title>Snow-Flow | Conversational ServiceNow Development Platform</title>
-    <meta name="description" content="Snow-Flow: Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 235+ ServiceNow tools including complete UI Builder integration for comprehensive platform development.">
+    <meta name="description" content="Snow-Flow: Conversational ServiceNow development platform using Claude Code. Multi-agent orchestration with 20+ MCP servers providing 240+ ServiceNow tools including complete 6-step UX Workspace creation workflow and UI Builder integration.">
     
     <!-- Modern CSS -->
     <link rel="stylesheet" href="css/style.css">
@@ -131,7 +131,7 @@
                 </span>
                 <span class="pill pill-pulse" style="animation-delay: 2.4s">
                     <span class="pill-icon">⚡</span>
-                    <span class="pill-text">235+ Tools + UI Builder</span>
+                    <span class="pill-text">240+ Tools + UX Workspace</span>
                 </span>
                 <span class="pill pill-float" style="animation-delay: 2.6s">
                     <span class="pill-icon">🏗️</span>
@@ -605,7 +605,7 @@ and historical patterns. Deploy as real-time API" \
                         <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_list_flows</li>
                         <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_execute_flow</li>
                         <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_get_flow_details</li>
-                        <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_create_workspace</li>
+                        <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_create_complete_workspace</li>
                         <li style="color: var(--gray-500); font-size: var(--font-xs); margin-bottom: var(--space-1);">• snow_configure_mobile_app</li>
                         <li style="color: var(--gray-500); font-size: var(--font-xs);">• snow_send_push_notification</li>
                     </ul>

package/website/tools.js

@@ -491,16 +491,41 @@ const snowFlowTools = {
         description: "Import flows from XML (only programmatic creation method)."
       },
       
-      // Configurable Agent Workspace Tools (UX App Architecture)
+      // 🏗️ COMPLETE UX WORKSPACE CREATION (6-Step Workflow)
       {
-        name: "snow_create_workspace",
-        description: "Create Configurable Agent Workspaces using modern UX App architecture (sys_ux_app_route, sys_ux_screen_type, sys_ux_screen, sys_ux_macroponent).",
-        highlight: "🏗️ UX App Architecture"
+        name: "snow_create_complete_workspace",
+        description: "Create Complete UX Workspace - Executes all 6 steps automatically: Experience → App Config → Page Macroponent → Page Registry → Route → Landing Page Route. Creates fully functional workspace.",
+        highlight: "🎆 COMPLETE WORKFLOW"
       },
       {
-        name: "snow_discover_workspaces",
-        description: "Discover available Configurable Agent Workspaces (UX Apps) with screen collections and individual screens.",
-        highlight: "🔍 UX App Discovery"
+        name: "snow_create_ux_experience",
+        description: "STEP 1: Create UX Experience Record (sys_ux_experience) - The top-level container for the workspace.",
+        highlight: "🏗️ Step 1"
+      },
+      {
+        name: "snow_create_ux_app_config",
+        description: "STEP 2: Create UX App Configuration Record (sys_ux_app_config) - Contains workspace settings and links to experience.",
+        highlight: "🏗️ Step 2"
+      },
+      {
+        name: "snow_create_ux_page_macroponent",
+        description: "STEP 3: Create Page Macroponent Record (sys_ux_macroponent) - Defines actual page content to be displayed.",
+        highlight: "🏗️ Step 3"
+      },
+      {
+        name: "snow_create_ux_page_registry",
+        description: "STEP 4: Create Page Registry Record (sys_ux_page_registry) - Registers page for use within workspace configuration.",
+        highlight: "🏗️ Step 4"
+      },
+      {
+        name: "snow_create_ux_app_route",
+        description: "STEP 5: Create Route Record (sys_ux_app_route) - Defines URL slug that leads to the page.",
+        highlight: "🏗️ Step 5"
+      },
+      {
+        name: "snow_update_ux_app_config_landing_page",
+        description: "STEP 6: Update App Configuration with Landing Page Route - Sets default landing page for workspace.",
+        highlight: "🏗️ Step 6"
       },
 
       // Mobile App Tools