snow-flow 1.1.82 → 1.1.84

package/CLAUDE.md

@@ -1,1103 +1,407 @@
 # Snow-Flow Development with Claude Code
 
-## 👑 Queen Agent - The claude-flow Revolution
+## 🚨 CRITICAL: MCP-FIRST WORKFLOW (READ THIS FIRST!)
 
-**The future of ServiceNow development is here!** The ServiceNow Queen Agent embodies the claude-flow philosophy: **elegant simplicity through hive-mind intelligence**.
+**Snow-flow's core value is REAL ServiceNow integration through MCP tools. NEVER work in offline mode!**
 
-### 🧠 Claude-Flow Philosophy
+### ⚠️ MANDATORY WORKFLOW - NO EXCEPTIONS
 
-Inspired by Claude's natural language capabilities, the Queen Agent transforms complex multi-agent orchestration into simple, intuitive commands. Just as Claude understands human intent from natural language, the Queen Agent understands development objectives and automatically orchestrates the perfect team.
-
-**Core Principles:**
-- **Hive-Mind Intelligence**: All agents share knowledge and learn collectively
-- **Intent-Driven Development**: Describe what you want, not how to build it  
-- **Memory-Driven Patterns**: Learn from every execution, improve over time
-- **Elegant Simplicity**: One command replaces complex coordination
-
-### 🚀 Primary Development Interface (RECOMMENDED)
-
-```bash
-# The Queen Agent - One Command Does Everything!
-snow-flow queen "create incident dashboard with charts and real-time data"
-snow-flow queen "build approval workflow for equipment requests"
-snow-flow queen "deploy mobile-responsive widget with accessibility features"
-snow-flow queen "create complete ITSM solution with custom tables and workflows"
-```
-
-#### Queen Commands Overview
-
-| Command | Purpose | Example |
-|---------|---------|----------|
-| `snow-flow queen "<objective>"` | Primary development command | `snow-flow queen "create incident widget"` |
-| `snow-flow queen-memory export [file]` | Export learning patterns | `snow-flow queen-memory export patterns.json` |
-| `snow-flow queen-memory import [file]` | Import previous learning | `snow-flow queen-memory import patterns.json` |
-| `snow-flow queen-memory clear --confirm` | Reset all learning | `snow-flow queen-memory clear --confirm` |
-| `snow-flow queen-status [--detailed]` | View hive-mind status | `snow-flow queen-status --detailed` |
-| `snow-flow queen-insights` | Get AI recommendations | `snow-flow queen-insights` |
-
-### 🔄 Enhanced Backward Compatibility
-
-```bash
-# Queen intelligence can enhance existing commands
-snow-flow swarm "create widget" --queen    # Adds Queen intelligence to swarm
-snow-flow sparc "create flow" --queen      # Queen-powered SPARC execution
-```
-
-### Queen vs Traditional Development
-
-| Traditional Approach | Queen Agent Approach |
-|---------------------|----------------------|
-| `snow-flow swarm "objective" --strategy development --mode hierarchical --max-agents 8 --parallel --monitor --shared-memory --validation --auto-deploy` | `snow-flow queen "objective" --monitor` |
-| `snow-flow sparc team widget "dashboard" --shared-memory --validation` | `snow-flow queen "create dashboard"` |
-| Complex team assembly and coordination | Automatic hive-mind orchestration |
-| Manual memory management | Memory-driven pattern learning |
-| Separate commands for different artifact types | Universal objective understanding |
-
-### 🧠 Queen Intelligence Features
-
-- **🎯 Automatic Agent Spawning**: Analyzes objectives and spawns optimal specialist teams
-- **📊 Memory-Driven Development**: Learns successful patterns and applies them automatically  
-- **🔄 Graceful Fallbacks**: Falls back to traditional methods when needed
-- **👑 Hive-Mind Coordination**: All agents share context and learn collectively
-- **🚀 One Command Philosophy**: Analyze → Spawn → Coordinate → Deploy in one step
-
-### 🎯 Quick Start with Queen (RECOMMENDED)
-
-```bash
-# 1. Initialize project
-snow-flow init --sparc
-
-# 2. Authenticate
-snow-flow auth login
-
-# 3. Start developing with Queen!
-snow-flow queen "create incident management dashboard with charts"
-
-# 4. Check learning status
-snow-flow queen-status --detailed
-
-# 5. Export learning for reuse
-snow-flow queen-memory export my-patterns.json
-```
-
----
-
-## 🚀 Core Development Principles
-
-### Concurrent Execution Strategy
-**Golden Rule**: "1 MESSAGE = ALL RELATED OPERATIONS"
-- Always batch related MCP tool calls in a single response
-- Use TodoWrite extensively for complex task coordination
-- Launch multiple agents concurrently for maximum performance
-- Leverage batch file operations whenever reading/writing multiple files
-
-### ServiceNow Development Best Practices
-1. **Never hardcode credentials** - Use OAuth and environment variables
-2. **Always work in Update Sets** - MANDATORY SEQUENCE:
-   a. FIRST: Create update set with `snow_update_set_create`
-   b. THEN: Switch to it with `snow_update_set_switch`  
-   c. TRACK: Every artifact with `snow_update_set_add_artifact`
-   d. CHECK: Current status with `snow_update_set_current`
-   e. COMPLETE: Mark complete with `snow_update_set_complete`
-3. **Test before deploy** - Use mock testing tools for validation
-4. **Validate permissions** - Check OAuth scopes before operations
-5. **Use fuzzy search** - ServiceNow names can vary (iPhone vs iPhone 6S)
-6. **Track all artifacts** - Use snow_update_set_add_artifact after EVERY deployment
-7. **Test with mock first** - Use snow_test_flow_with_mock before comprehensive testing
-8. **Verify before test** - Check artifact exists with snow_get_by_sysid before testing
-
-### Update Set Best Practices
-- NEVER deploy without active update set
-- ALWAYS track artifacts immediately after deployment
-- CHECK current update set before starting work
-- COMPLETE update sets before moving between environments
-
-## 🔒 MANDATORY ServiceNow Development Workflow (v1.1.79+)
-
-### 🚨 CRITICAL: All ServiceNow Operations MUST Follow This Workflow
-
-**Every single ServiceNow operation must start with authentication validation!** The MCP servers now automatically enforce this workflow.
-
-#### **STEP 1: MANDATORY Authentication Validation**
+**Every ServiceNow task MUST start with this sequence:**
 
 ```javascript
-// This happens automatically in ALL MCP tools
-const connectionResult = await validateServiceNowConnection();
-if (!connectionResult.success) {
-  return createAuthenticationError(connectionResult.error);
+// 1. MANDATORY: Pre-flight authentication check
+const authCheck = await snow_validate_live_connection({ test_level: "permissions" });
+if (!authCheck.success) {
+  // STOP! Fix authentication first
+  return authenticationError(authCheck.error);
 }
-```
-
-**What This Checks:**
-1. ✅ **Credentials Exist**: .env file has OAuth settings
-2. ✅ **OAuth Session Active**: Valid access token exists  
-3. ✅ **Token Valid**: Not expired, auto-refresh if needed
-4. ✅ **Live Connection**: Actual ServiceNow instance responds
-
-**If Authentication Fails, You Get:**
-```
-❌ ServiceNow Connection Failed
-
-OAuth authentication required. Run "snow-flow auth login" to authenticate.
 
-🔧 To fix this:
-
-1. Ensure .env file has OAuth credentials:
-   SNOW_INSTANCE=your-instance.service-now.com
-   SNOW_CLIENT_ID=your_oauth_client_id
-   SNOW_CLIENT_SECRET=your_oauth_client_secret
+// 2. MANDATORY: Discovery before creation
+const discovery = await snow_find_artifact({ 
+  query: "your objective",
+  type: "widget|flow|script|any" 
+});
 
-2. Authenticate with ServiceNow:
-   snow-flow auth login
+// 3. MANDATORY: Real ServiceNow deployment
+const deployment = await snow_deploy({
+  type: "widget|flow|application",
+  config: { /* your config */ },
+  auto_update_set: true  // Always track changes
+});
 
-3. If you still get errors, run diagnostics:
-   snow_auth_diagnostics()
+// 4. MANDATORY: Track in Update Set
+await snow_update_set_add_artifact({
+  type: deployment.type,
+  sys_id: deployment.result.sys_id,
+  name: deployment.result.name
+});
 ```
 
-#### **STEP 2: Smart Artifact Discovery (DRY Principle)**
-
-```javascript
-// Automatic discovery before creating anything new
-const discovery = await discoverExistingArtifacts(
-  type,           // 'widget', 'flow', 'script', etc.
-  artifactName,   // Extracted from instruction/config
-  searchTerms     // Related keywords for comprehensive search
-);
-
-if (discovery.found) {
-  console.log(`🔍 Found ${discovery.artifacts.length} existing artifacts`);
-  console.log(`💡 Suggestions: ${discovery.suggestions.join(', ')}`);
-}
-```
+### 🚫 FORBIDDEN ACTIONS
 
-**Discovery Results Include:**
-- 📋 **Existing Artifacts**: Similar names and functionality
-- 💡 **Reuse Suggestions**: "Consider reusing: Widget A, Widget B"  
-- 🔍 **Related Items**: Found by description and keywords
-- ⚠️ **Duplication Warnings**: Prevents creating identical artifacts
+**THESE ACTIONS ARE BANNED - NEVER DO THESE:**
 
-#### **STEP 3: Automatic Update Set Management**
+❌ **Creating local files** without MCP check first  
+❌ **Generating mock data** instead of using MCP tools  
+❌ **Working in "offline mode"** when ServiceNow is available  
+❌ **Skipping authentication validation**  
+❌ **Planning mode** without trying MCP tools first  
 
-```javascript
-// Automatic Update Set creation and tracking
-const updateSetId = await ensureUpdateSet(context, purpose);
+### ✅ CORRECT: MCP-First Decision Tree
 
-// After every deployment
-await trackArtifact(sysId, type, name, updateSetId);
 ```
-
-**Update Set Features:**
-- 📦 **Auto-Creation**: Creates Update Set if none exists
-- 🏷️ **Smart Naming**: `Snow-Flow Widget Deployment - 2024-01-15`
-- 📋 **Auto-Tracking**: Every artifact automatically tracked
-- 🔄 **Session Management**: Links to Agent session for coordination
-
-### 🛡️ Error Recovery Patterns with Specific Next Steps
-
-#### **Authentication Errors (403, 401)**
-
-```javascript
-// OLD: Generic error
-❌ "Authentication failed"
-
-// NEW: Specific recovery steps
-❌ ServiceNow Connection Failed
-
-OAuth token expired and refresh failed. Run "snow-flow auth login" to re-authenticate.
-
-🔧 To fix this:
-1. Check .env credentials are correct
-2. Run: snow-flow auth login  
-3. If issues persist: snow_auth_diagnostics()
+User Request → ALWAYS START HERE:
+    ↓
+1. snow_validate_live_connection()
+    ↓
+   SUCCESS? → Continue to Step 2
+    ↓
+   FAILURE? → Fix auth: snow_auth_diagnostics()
+              Then guide user: "snow-flow auth login"
+              STOP until auth works
+    ↓
+2. snow_find_artifact() // Check if exists
+    ↓
+   FOUND? → Ask: "Reuse existing or create new?"
+    ↓
+   NOT FOUND? → Continue to Step 3
+    ↓
+3. snow_deploy() // Real deployment to ServiceNow
+    ↓
+   SUCCESS? → Step 4: Track in Update Set
+    ↓
+   FAILURE? → Use fallback strategies (see below)
+    ↓
+4. snow_update_set_add_artifact() // Always track
+    ↓
+   DONE! ✅
 ```
 
-#### **Deployment Errors with Fallback Strategies**
+## 🔧 Error Recovery - MCP Fallback Strategies
 
+**Only if MCP tools fail, use these fallbacks:**
+
+### Authentication Failures
 ```javascript
-// Automatic fallback strategies
-if (deployment.failed) {
-  // Strategy 1: Try global scope
-  if (error.includes('insufficient privileges')) {
-    await escalateToGlobalScope();
-  }
-  
-  // Strategy 2: Manual steps guide  
-  if (fallback_strategy === 'manual_steps') {
-    return createManualStepsGuide(artifact, error);
-  }
-  
-  // Strategy 3: Update Set only
-  if (fallback_strategy === 'update_set_only') {
-    await createUpdateSetWithInstructions(artifact);
-  }
-}
-```
+if (error.includes('authentication') || error.includes('401') || error.includes('403')) {
+  return `
+❌ ServiceNow Authentication Required
 
-#### **Discovery Conflicts with Resolution Options**
+Fix this now:
+1. Run: snow-flow auth login
+2. Check .env: SNOW_INSTANCE, SNOW_CLIENT_ID, SNOW_CLIENT_SECRET
+3. Test: snow_validate_live_connection()
 
-```javascript
-// When existing artifacts found
-if (discovery.found) {
-  return {
-    options: [
-      "1. Reuse existing: incident_dashboard_v2 (recommended)",
-      "2. Extend existing with new features", 
-      "3. Create new with different name: incident_dashboard_v3",
-      "4. Override existing (not recommended)"
-    ],
-    recommendations: [
-      "✅ Reusing saves development time",
-      "⚠️ Check if existing meets requirements first",
-      "💡 Consider extending instead of duplicating"
-    ]
-  };
+Cannot proceed until authentication works!
+  `;
 }
 ```
 
-### 🔧 Enhanced OAuth Implementation (v1.1.79+)
-
-#### **Environment Variable Fallback**
-
-The OAuth system now properly supports .env fallback:
-
+### Permission Escalation
 ```javascript
-// 1. Try OAuth tokens from ~/.snow-flow/auth.json
-// 2. Fallback to .env credentials if no tokens
-// 3. Provide specific error messages for each failure
-
-async loadCredentials(): Promise<ServiceNowCredentials | null> {
-  // Try saved OAuth tokens first
-  const tokens = await this.loadTokens();
-  if (tokens?.accessToken) {
-    return tokens;  // ✅ Valid session found
-  }
-  
-  // 🔧 NEW: Fallback to .env file
-  const envCredentials = this.loadFromEnv();
-  if (envCredentials) {
-    // Return credentials without accessToken - signals OAuth login needed
-    return envCredentials;
-  }
-  
-  // ❌ No credentials found anywhere
-  return null;
+if (error.includes('insufficient privileges')) {
+  await snow_escalate_permissions({
+    required_roles: ['admin', 'app_creator'],
+    reason: 'ServiceNow development requires elevated permissions'
+  });
 }
 ```
 
-#### **Automatic Token Refresh**
-
+### Deployment Failures - Graceful Degradation
 ```javascript
-// Smart token management
-if (token.expired) {
-  console.log('🔄 Token expired, attempting refresh...');
+if (deployment.failed) {
+  // Strategy 1: Try global scope
+  const globalAttempt = await snow_deploy({ 
+    ...config, 
+    scope_preference: 'global' 
+  });
   
-  const refreshResult = await oauth.refreshAccessToken();
-  if (refreshResult.success) {
-    console.log('✅ Token refreshed successfully');
-  } else {
-    return authenticationError('Token refresh failed - login required');
+  if (globalAttempt.failed) {
+    // Strategy 2: Manual steps guide
+    return createManualStepsGuide(config, error);
   }
 }
 ```
 
-### 📋 MANDATORY Pre-Flight Checklist
+## 🚀 Swarm Command - MCP-Orchestrated Multi-Agent Intelligence
 
-Before ANY ServiceNow development, ensure:
+**The Swarm system is now MCP-native and ALWAYS uses ServiceNow tools first!**
 
-#### **Environment Setup**
-- [ ] ✅ `.env` file has SNOW_INSTANCE, SNOW_CLIENT_ID, SNOW_CLIENT_SECRET
-- [ ] ✅ `snow-flow auth login` completed successfully  
-- [ ] ✅ `snow_validate_live_connection()` returns success
-
-#### **Development Workflow**
-- [ ] ✅ Start with discovery: `snow_find_artifact()` or `snow_comprehensive_search()`
-- [ ] ✅ Check for reusable components before creating new
-- [ ] ✅ Ensure active Update Set before deployment
-- [ ] ✅ Test with mock data first: `snow_test_flow_with_mock()`
-
-#### **Deployment Verification** 
-- [ ] ✅ All artifacts tracked in Update Set
-- [ ] ✅ Authentication validated before each operation
-- [ ] ✅ Error recovery plan in place
-- [ ] ✅ Rollback strategy documented
-
-### 🚨 Queen Agent Must Develop IN ServiceNow First
-
-**CRITICAL RULE**: The Queen Agent and all specialists must always develop directly in the live ServiceNow instance using the MCP tools, never create local documentation or placeholder code.
+### 🚀 Primary Development Interface (RECOMMENDED)
 
 ```bash
-# ✅ CORRECT: Live development
-snow-flow queen "create incident widget"
-# → Queen uses snow_deploy() with real ServiceNow instance
-# → Creates actual widget in ServiceNow
-# → Tracks in Update Set
-# → Returns sys_id and live URL
-
-# ❌ INCORRECT: Local/mock development  
-# → Creates local HTML/CSS files
-# → Uses placeholder data
-# → No ServiceNow integration
+# Swarm with automatic MCP-first workflow
+snow-flow swarm "create incident dashboard with charts and real-time data"
+snow-flow swarm "build approval workflow for equipment requests"  
+snow-flow swarm "deploy mobile-responsive widget with accessibility features"
 ```
 
-**Why This Matters:**
-- 🎯 **Real Validation**: Only live environment shows real constraints
-- 🔗 **Actual Integration**: Real data connections and dependencies
-- 📋 **Proper Tracking**: Update Sets only work with live changes
-- 🚀 **Immediate Value**: User can see and test results instantly
-
-## 🎯 Simplified Deployment API (v1.1.73+)
-
-### One Tool for All Deployments
-**NEW**: All deployment operations now use the unified `snow_deploy` tool instead of multiple separate tools:
-
-```javascript
-// ✅ SIMPLIFIED API - One tool for everything
-snow_deploy({
-  type: "widget",           // widget, flow, application, script, batch
-  config: { ... },          // Configuration for widgets/scripts
-  instruction: "...",       // Natural language for flows
-  artifacts: [...],         // For batch deployments
-  dry_run: false,          // Preview mode
-  parallel: true,          // Batch optimization
-  transaction_mode: true   // All-or-nothing deployment
-});
-```
+**What happens internally in every swarm:**
+1. ✅ **Pre-flight auth check** with `snow_validate_live_connection()`
+2. ✅ **Smart discovery** with `snow_comprehensive_search()`  
+3. ✅ **Multi-agent coordination** with shared MCP context
+4. ✅ **Real deployment** with `snow_deploy()`
+5. ✅ **Automatic tracking** with `snow_update_set_add_artifact()`
+6. ✅ **Live testing** with `snow_test_flow_with_mock()` or `snow_widget_test()`
 
-### Backward Compatibility
-All old deployment tools still work but show deprecation warnings:
-- `snow_deploy_widget()` → redirects to `snow_deploy({type: "widget"})`
-- `snow_deploy_flow()` → redirects to `snow_deploy({type: "flow"})`  
-- `snow_deploy_application()` → redirects to `snow_deploy({type: "application"})`
-- `snow_bulk_deploy()` → redirects to `snow_deploy({type: "batch"})`
+### Swarm MCP Integration Features
 
-### Benefits
-- **75% fewer deployment commands** - One tool instead of 4+
-- **Consistent interface** - Same parameters across all artifact types
-- **Automatic fallbacks** - Built-in resilience and error recovery
-- **Better error messages** - Unified error handling and guidance
+- **🎯 Auto MCP Validation**: Every swarm operation starts with auth check
+- **📊 Smart Discovery**: Uses `snow_comprehensive_search()` to find existing artifacts  
+- **🔄 Update Set Management**: Automatic `snow_smart_update_set()` creation
+- **🐝 Swarm Coordination**: All agents share MCP context and coordinate via real ServiceNow data
+- **🚀 Live Deployment**: Direct ServiceNow integration via MCP tools
+- **⚡ Parallel Execution**: Multiple agents work simultaneously on ServiceNow
 
-## 📋 Essential MCP Tool Patterns
+## 🔒 MANDATORY ServiceNow Development Workflow
 
-### Batch Operations for Maximum Efficiency
-```javascript
-// GOOD: Single message with multiple tool calls
-TodoWrite([...tasks]);
-Task("Architect", "Design system architecture");
-Task("Developer", "Implement components");
-Task("Tester", "Create test scenarios");
-
-// BAD: Sequential single operations
-TodoWrite([task1]);
-// wait for response
-TodoWrite([task2]);
-// wait for response
-```
+### **STEP 1: Authentication Validation (ALWAYS FIRST)**
 
-### Memory-Driven Coordination
-Use Memory to coordinate information across agents:
 ```javascript
-// Store architecture decisions
-snow_memory_store({
-  key: "widget_architecture",
-  value: "Service Portal widget with Chart.js for data visualization"
+// This happens automatically in ALL MCP tools
+const connectionResult = await snow_validate_live_connection({
+  test_level: "permissions"  // Test actual write capabilities
 });
 
-// All agents can reference this
-Task("Frontend Dev", "Implement widget based on widget_architecture in memory");
-Task("Backend Dev", "Create REST endpoints for widget_architecture requirements");
-```
-
-### Team-Driven Development Coordination
-Use specialized teams for complex ServiceNow development:
-
-```bash
-# Team with shared memory and quality gates
-snow-flow sparc team widget "dashboard" --shared-memory --validation --monitor
-
-# Store team requirements and coordination data
-snow-flow memory store "team_requirements" "Dashboard with real-time KPIs and mobile responsiveness"
+if (!connectionResult.success) {
+  throw new AuthenticationError(`
+❌ ServiceNow Connection Failed: ${connectionResult.error}
 
-# All team specialists can access shared context
-snow-flow memory get "team_requirements"
+🔧 Fix this now:
+1. Check .env credentials
+2. Run: snow-flow auth login  
+3. Test: snow_auth_diagnostics()
+  `);
+}
 ```
 
-## 🛠️ Complete ServiceNow MCP Tools Reference
+### **STEP 2: Smart Discovery (Prevent Duplication)**
 
-### Discovery & Search Tools
 ```javascript
-// Find any ServiceNow artifact using natural language
-snow_find_artifact({
-  query: "the widget that shows incidents on homepage",
-  type: "widget" // or "flow", "script", "application", "any"
-});
-
-// Search catalog items with fuzzy matching
-snow_catalog_item_search({
-  query: "laptop",
-  fuzzy_match: true,        // Finds variations: notebook, MacBook, etc.
-  category_filter: "hardware",
-  include_variables: true   // Get catalog variables too
+// ALWAYS check before creating
+const discovery = await snow_comprehensive_search({
+  query: "incident dashboard widget",
+  include_inactive: false
 });
 
-// Direct sys_id lookup (faster than search)
-snow_get_by_sysid({
-  sys_id: "abc123...",
-  table: "sp_widget"
-});
+if (discovery.found.length > 0) {
+  console.log(`🔍 Found ${discovery.found.length} similar artifacts:`);
+  discovery.found.forEach(artifact => {
+    console.log(`💡 Consider reusing: ${artifact.name} (${artifact.sys_id})`);
+  });
+}
 ```
 
-### Flow Development Tools
-```javascript
-// Create flows from natural language
-snow_create_flow({
-  instruction: "create a flow that sends email when incident priority is high",
-  deploy_immediately: true,
-  enable_intelligent_analysis: true
-});
-
-// Test flows with mock data
-snow_test_flow_with_mock({
-  flow_id: "incident_notification_flow",
-  create_test_user: true,
-  mock_catalog_items: true,
-  test_inputs: {
-    priority: "1",
-    category: "hardware"
-  },
-  simulate_approvals: true
-});
-
-// Link catalog items to flows
-snow_link_catalog_to_flow({
-  catalog_item_id: "New Laptop Request",
-  flow_id: "laptop_provisioning_flow",
-  link_type: "flow_catalog_process",
-  variable_mapping: [
-    {
-      catalog_variable: "laptop_model",
-      flow_input: "equipment_type"
-    }
-  ]
-});
-```
+### **STEP 3: Real ServiceNow Deployment**
 
-### Widget Development Tools
 ```javascript
-// Deploy widgets with automatic validation (SIMPLIFIED API v1.1.73+)
-snow_deploy({
+// Deploy directly to ServiceNow - NO local files!
+const deployment = await snow_deploy({
   type: "widget",
   config: {
     name: "incident_dashboard",
-    title: "Incident Dashboard",
+    title: "Incident Dashboard", 
     template: htmlContent,
-    css: cssContent,
-    client_script: clientJS,
     server_script: serverJS,
-    demo_data: { incidents: [...] }
-  }
-});
-
-// OLD API (deprecated but still works with automatic redirection)
-// snow_deploy_widget() - shows deprecation warning, redirects to snow_deploy
-
-// Preview and test widgets
-snow_preview_widget({
-  widget_id: "incident_dashboard",
-  check_dependencies: true
-});
-
-snow_widget_test({
-  widget_id: "incident_dashboard",
-  test_scenarios: [
-    {
-      name: "Load with no data",
-      server_data: { incidents: [] }
-    }
-  ]
+    client_script: clientJS,
+    css: cssStyles
+  },
+  auto_update_set: true,    // Automatic Update Set management
+  fallback_strategy: "manual_steps"  // Graceful degradation
 });
 ```
 
-### Bulk Operations
-```javascript
-// Deploy multiple artifacts at once (SIMPLIFIED API v1.1.73+)
-snow_deploy({
-  type: "batch",
-  artifacts: [
-    { type: "widget", config: widgetData },
-    { type: "flow", instruction: "approval flow" },
-    { type: "script", config: scriptData }
-  ],
-  transaction_mode: true,     // All or nothing
-  parallel: true,            // Deploy simultaneously  
-  dry_run: false
-});
+### **STEP 4: Automatic Update Set Tracking**
 
-// OLD API (deprecated but still works with automatic redirection)
-// snow_bulk_deploy() - shows deprecation warning, redirects to snow_deploy
-```
-
-### Intelligent Analysis
 ```javascript
-// Analyze incidents with AI
-snow_analyze_incident({
-  incident_id: "INC0010001",
-  include_similar: true,
-  suggest_resolution: true
+// Every deployment is automatically tracked
+await snow_update_set_add_artifact({
+  type: deployment.type,
+  sys_id: deployment.result.sys_id,
+  name: deployment.result.name
 });
 
-// Pattern analysis
-snow_pattern_analysis({
-  analysis_type: "incident_patterns",
-  timeframe: "month"
-});
+console.log(`✅ Widget deployed: ${deployment.result.sys_id}`);
+console.log(`📋 Tracked in Update Set: ${deployment.update_set_id}`);
 ```
 
-## Flow Testing Guidelines
-
-### Test Flow Hierarchy (use in this order):
-1. **snow_test_flow_with_mock** - Always works, use for basic validation
-2. **snow_get_by_sysid** - Verify flow exists before advanced testing  
-3. **snow_comprehensive_flow_test** - Only if above work (often 404)
+## 🎯 MCP Tool Reference (Use These ALWAYS!)
 
-### Flow Creation Best Practices
-❌ NEVER use snow_deploy_flow with manual JSON
-✅ ALWAYS use snow_create_flow with natural language
-✅ OR use snow_flow_wizard for step-by-step
-
-Example:
+### Core Deployment Tools
 ```javascript
-// BEST - Natural language with simplified deployment (v1.1.73+)
-snow_create_flow({
-  instruction: "create approval flow for user provisioning",
-  deploy_immediately: true
-})
+// Universal deployment (replaces all old deploy_* tools)
+snow_deploy({ type: "widget|flow|application", config: {...} })
 
-// ALTERNATIVE - Direct deployment with simplified API
-snow_deploy({
-  type: "flow", 
-  instruction: "approval flow for user provisioning"
-})
-
-// OLD API (deprecated but still works with automatic redirection)
-// snow_deploy_flow() - shows deprecation warning, redirects to snow_deploy
-```
+// Smart artifact discovery  
+snow_find_artifact({ query: "natural language", type: "widget" })
+snow_comprehensive_search({ query: "broader search" })
 
-## ⚡ Performance Optimization
+// Live connection testing
+snow_validate_live_connection({ test_level: "permissions" })
 
-### Parallel Execution Patterns
-```javascript
-// Execute multiple searches concurrently
-Promise.all([
-  snow_find_artifact({ query: "incident widget" }),
-  snow_catalog_item_search({ query: "laptop" }),
-  snow_query_incidents({ query: "priority=1" })
-]);
+// Update Set management (automatic in snow_deploy)
+snow_smart_update_set({ auto_track_related_artifacts: true })
 ```
 
-### Batch File Operations
+### Testing & Validation Tools
 ```javascript
-// Read multiple files in one operation
-MultiRead([
-  "/path/to/widget.html",
-  "/path/to/widget.css",
-  "/path/to/widget.js"
-]);
-```
-
-## 📝 Workflow Guidelines
-
-### Standard Development Flow
-1. **Discovery Phase**: Use search tools to find existing artifacts
-2. **Planning Phase**: Use TodoWrite to plan all tasks
-3. **Development Phase**: Launch agents concurrently
-4. **Testing Phase**: Use mock testing tools
-5. **Deployment Phase**: Use simplified snow_deploy with validation
-
-### Error Recovery Patterns
-```javascript
-// Always implement rollback strategies
-if (deployment.failed) {
-  snow_deployment_rollback_manager({
-    update_set_id: deployment.update_set,
-    restore_point: deployment.backup_id
-  });
-}
-```
-
-## 🔧 Advanced Configuration
-
-## Build Commands
-- `npm run build`: Build the project
-- `npm run test`: Run the full test suite
-- `npm run lint`: Run ESLint and format checks
-- `npm run typecheck`: Run TypeScript type checking
-
-## Snow-Flow Commands
-- `snow-flow init --sparc`: Initialize project with SPARC environment
-- `snow-flow auth login`: Authenticate with ServiceNow OAuth
-- `snow-flow swarm "<objective>"`: Start multi-agent swarm - één command voor alles!
-- `snow-flow sparc <mode> "<task>"`: Run specific SPARC mode
-
-## Enhanced Swarm Command with Queen Agent Orchestration (v1.1.75+)
-
-### 👑 Queen Agent Architecture
-The swarm command now uses Queen Agent orchestration, where a master coordinator spawns and manages specialized agents through Claude Code:
-
-```bash
-# Simple usage - Queen Agent handles everything!
-snow-flow swarm "create incident management dashboard"
-```
-
-### What Happens:
-1. **Memory Initialization**: SQLite-based swarm memory system starts
-2. **Session Creation**: Unique session ID generated for tracking
-3. **Queen Agent Launch**: Master coordinator analyzes objective
-4. **Agent Spawning**: Specialized agents created via Task tool
-5. **Memory Coordination**: Agents communicate through shared memory
-6. **Progress Monitoring**: Real-time status updates via TodoWrite
-
-### Default Settings (no flags needed):
-- ✅ `--smart-discovery` - Automatically discovers and reuses existing artifacts
-- ✅ `--live-testing` - Tests in real-time on your ServiceNow instance
-- ✅ `--auto-deploy` - Deploys automatically (safe with update sets)
-- ✅ `--auto-rollback` - Automatically rollbacks on failures
-- ✅ `--shared-memory` - All agents share context and coordination
-- ✅ `--progress-monitoring` - Real-time progress tracking
-- ❌ `--auto-permissions` - Disabled by default (enable with flag for automatic role elevation)
-
-### Advanced Usage:
-```bash
-# Enable automatic permission escalation
-snow-flow swarm "create global workflow" --auto-permissions
-
-# Disable specific features
-snow-flow swarm "test widget" --no-auto-deploy --no-live-testing
-
-# Full control with Queen Agent
-snow-flow swarm "complex integration" \
-  --max-agents 8 \
-  --strategy development \
-  --mode hierarchical \
-  --parallel \
-  --auto-permissions
-```
-
-### Monitoring Swarm Progress:
-```bash
-# Check status of a running swarm
-snow-flow swarm-status <sessionId>
+// Test flows with mock data (safer than live testing)
+snow_test_flow_with_mock({ 
+  flow_id: "approval_flow",
+  create_test_user: true,
+  cleanup_after_test: true 
+})
 
-# Continuously monitor progress
-snow-flow swarm-status <sessionId> --watch --interval 10
+// Widget testing
+snow_widget_test({ 
+  sys_id: "widget_sys_id",
+  test_scenarios: [...] 
+})
 
-# List recent swarm sessions
-snow-flow swarm-status
+// Live deployment validation
+snow_validate_deployment({ type: "widget", artifact: {...} })
 ```
 
-### Queen Agent Memory Patterns:
-The Queen Agent uses these memory keys for coordination:
-- `swarm_session_<sessionId>` - Main session data
-- `agent_<type>_progress` - Individual agent progress
-- `agent_<type>_complete` - Agent completion status
-- `swarm_session_<sessionId>_results` - Final results
-
-
-## New MCP Tools (v1.1.44+)
-
-### Catalog Item Search
-Find catalog items with intelligent fuzzy matching:
+### Authentication & Recovery Tools
 ```javascript
-snow_catalog_item_search({
-  query: "iPhone",          // Will find iPhone 6S, iPhone 7, etc.
-  fuzzy_match: true,        // Enable intelligent variations
-  include_variables: true   // Include catalog variables
+// Authentication diagnostics
+snow_auth_diagnostics({ 
+  run_write_test: true,
+  include_recommendations: true 
 })
-```
 
-### Flow Testing with Mock Data
-Test flows without real data:
-```javascript
-snow_test_flow_with_mock({
-  flow_id: "equipment_provisioning_flow",
-  create_test_user: true,      // Creates test user
-  mock_catalog_items: true,    // Creates test catalog items
-  simulate_approvals: true,    // Auto-approves during test
-  cleanup_after_test: true     // Removes test data after
+// Permission escalation (when needed)
+snow_escalate_permissions({
+  required_roles: ['admin'],
+  reason: 'Widget deployment requires admin access'
 })
 ```
 
-### Direct Catalog-Flow Linking
-Link catalog items directly to flows:
-```javascript
-snow_link_catalog_to_flow({
-  catalog_item_id: "iPhone 6S",
-  flow_id: "mobile_provisioning_flow",
-  link_type: "flow_catalog_process",  // Modern approach
-  variable_mapping: [
-    {
-      catalog_variable: "phone_model",
-      flow_input: "device_type"
-    }
-  ],
-  test_link: true  // Creates test request
-})
-```
+## 🚨 Error Patterns & Recovery
 
-### OAuth Configuration
-```env
-# .env file
-SNOW_INSTANCE=dev123456
-SNOW_CLIENT_ID=your_oauth_client_id
-SNOW_CLIENT_SECRET=your_oauth_client_secret
-SNOW_USERNAME=admin
-SNOW_PASSWORD=admin_password
-```
+### Common Errors & MCP Solutions
 
-### Update Set Management
+**Authentication Errors (401/403)**
 ```javascript
-// Smart update set creation
-snow_smart_update_set({
-  name: "Auto-generated for widget development",
-  detect_context: true,  // Auto-detects what you're working on
-  auto_switch: true     // Switches when context changes
-});
-```
-
-## 🚀 NEW: Team-Based Agent Architecture (v1.1.62+)
-
-### Specialized Development Teams
-
-Snow-Flow now uses specialized teams that mirror real software development teams, replacing monolithic agents with expert specialists:
-
-#### **Widget Development Team**
-```bash
-# Complete widget development with specialized roles
-snow-flow sparc team widget "create incident dashboard with charts and filters"
-```
-
-**Team Composition:**
-- 🎨 **Frontend Developer**: HTML templates, CSS styling, responsive design
-- ⚙️ **Backend Developer**: Server scripts, API calls, data processing
-- 🖼️ **UI/UX Designer**: User experience, design patterns, accessibility
-- 🔧 **ServiceNow Specialist**: Platform integration, best practices
-- 🧪 **QA Tester**: Widget testing, validation, edge cases
-
-#### **Flow Development Team**
-```bash
-# Complete flow development with process experts
-snow-flow sparc team flow "build approval process for equipment requests"
-```
-
-**Team Composition:**
-- 🔄 **Process Designer**: Business logic, workflow design
-- 🎯 **Trigger Specialist**: Event handling, conditions, automation
-- 📊 **Data Specialist**: Variables, transformations, integrations
-- 🔗 **Integration Expert**: APIs, external systems, data sync
-- 🛡️ **Security Reviewer**: Permissions, validation, compliance
-
-#### **Application Development Team**
-```bash
-# Complete application development with enterprise specialists
-snow-flow sparc team app "create complete ITSM solution with custom tables"
-```
-
-**Team Composition:**
-- 🏗️ **Database Designer**: Tables, relationships, indexes, performance
-- 🎯 **Business Logic Developer**: Rules, scripts, calculations
-- 🎨 **Interface Designer**: Forms, lists, UI components
-- 🔐 **Security Engineer**: ACLs, roles, access control
-- 📈 **Performance Optimizer**: Queries, caching, efficiency
-
-#### **Adaptive Team (Generic Scenario)**
-```bash
-# For unknown/custom tasks - dynamically assembled specialists
-snow-flow sparc team adaptive "create integration between ServiceNow and external API"
-```
-
-**Dynamic Assembly:**
-- 🤖 **Task Analyzer**: Understands requirements and assembles optimal team
-- 🔧 **Specialist Pool**: Data, Integration, Automation, Security, Reporting specialists
-- 📋 **Coordination Patterns**: Sequential, parallel, or hybrid execution
-- 🎯 **Quality Gates**: Validation checkpoints between specialist handoffs
-
-### Team Coordination Features
-
-#### **Shared Memory System**
-Teams share context and communicate through intelligent memory:
-```bash
-# Enable shared memory (default: true)
-snow-flow sparc team widget "dashboard" --shared-memory
-```
-
-- **Context Sharing**: All specialists access shared requirements and progress
-- **Version Control**: Track changes and enable rollback if needed
-- **Real-time Updates**: Specialists notified when dependencies complete
-
-#### **Quality Gates**
-Automated validation between specialist handoffs:
-```bash
-# Enable validation gates (recommended)
-snow-flow sparc team flow "approval" --validation
-```
-
-**Quality Gate Types:**
-- **Code Quality**: Syntax, standards, best practices
-- **Security Review**: Vulnerability scanning, access controls
-- **Performance Check**: Query optimization, response times
-- **Accessibility**: WCAG compliance, usability testing
-
-#### **Execution Patterns**
-Teams automatically select optimal coordination:
-
-**Sequential Pattern** (Dependencies):
-```
-Architecture → Database → Business Logic → Interface → Testing
+if (error.status === 401 || error.status === 403) {
+  const diagnostics = await snow_auth_diagnostics();
+  if (!diagnostics.oauth_configured) {
+    return "Run: snow-flow auth login";
+  }
+  if (diagnostics.token_expired) {
+    return "Token expired - please re-authenticate";
+  }
+}
 ```
 
-**Parallel Pattern** (Independent work):
-```
-Frontend ⟷ Backend ⟷ Security ⟷ Testing (simultaneously)
+**Permission Errors**
+```javascript
+if (error.includes('insufficient privileges')) {
+  await snow_escalate_permissions({
+    required_roles: ['admin', 'app_creator'],
+    workflow_context: 'ServiceNow widget development'
+  });
+}
 ```
 
-**Hybrid Pattern** (Optimized):
-```
-Phase 1: Architecture (sequential)
-Phase 2: Frontend + Backend + Security (parallel)  
-Phase 3: Integration + Testing (sequential)
+**Deployment Conflicts**
+```javascript
+if (error.includes('already exists')) {
+  const existing = await snow_find_artifact({ 
+    query: config.name, 
+    type: config.type 
+  });
+  
+  return `
+🔍 Artifact exists: ${existing.name} (${existing.sys_id})
+Options:
+1. Update existing: snow_edit_by_sysid()
+2. Create with different name
+3. Use existing as-is
+  `;
+}
 ```
 
-### Individual Specialist Modes
-
-Access specific specialists directly for focused tasks:
+## 📋 Quick Start Workflows
 
+### 🚀 Widget Development (MCP-First)
 ```bash
-# Frontend specialist
-snow-flow sparc frontend "optimize widget responsiveness for mobile"
+# 1. Authentication check (automatic in Swarm)
+snow-flow swarm "create incident dashboard widget"
 
-# Backend specialist  
-snow-flow sparc backend "optimize database queries for performance"
-
-# Security specialist
-snow-flow sparc security "review application access controls"
-
-# Data specialist
-snow-flow sparc data "design table relationships for ITSM"
-
-# Integration specialist
-snow-flow sparc integration "create REST API for external system"
-```
-
-### Team Command Options
-
-```bash
-# Basic team execution
-snow-flow sparc team widget "create dashboard"
-
-# Advanced coordination options
-snow-flow sparc team widget "dashboard" \
-  --parallel \           # Enable parallel execution
-  --monitor \           # Real-time progress monitoring
-  --shared-memory \     # Enable context sharing (default: true)
-  --validation \        # Enable quality gates (recommended)
-  --dry-run            # Preview team assembly and plan
-
-# Specialist-specific options
-snow-flow sparc frontend "template" \
-  --responsive \        # Focus on mobile responsiveness
-  --accessibility      # WCAG compliance focus
+# Manual MCP workflow (what happens internally):
+# snow_validate_live_connection() → snow_find_artifact() → snow_deploy() → snow_update_set_add_artifact()
 ```
 
-### Team vs Individual Agent Comparison
-
-| Scenario | Old Approach | New Team Approach |
-|----------|-------------|-------------------|
-| **Widget Creation** | Single agent does everything | Frontend + Backend + UI/UX + Platform specialists |
-| **Flow Development** | Flow agent handles all aspects | Process + Trigger + Data + Security specialists |
-| **Complex Integration** | Generic coder attempts everything | Adaptive team assembles: Integration + Data + Security + Testing |
-| **Quality Assurance** | No systematic validation | Quality gates between each specialist handoff |
-| **Knowledge Sharing** | Isolated agent knowledge | Shared memory with version control |
-
-### Best Practices for Team Usage
-
-#### **When to Use Teams vs Individual Agents**
-
-**✅ Use Teams For:**
-- Complete widget/flow/application development
-- Complex multi-component tasks
-- Production-quality deliverables
-- When you need multiple expertise areas
-
+### 🔄 Flow Development (MCP-First)  
 ```bash
-# Good: Complete solution
-snow-flow sparc team widget "create executive dashboard with KPIs"
+# Swarm handles all MCP orchestration with multiple agents
+snow-flow swarm "create approval workflow for equipment requests"
 
-# Good: Complex process
-snow-flow sparc team flow "multi-step approval with integrations"
+# What happens: snow_create_flow() → snow_test_flow_with_mock() → multi-agent validation → auto tracking
 ```
 
-**✅ Use Individual Specialists For:**
-- Focused single-component tasks
-- Quick fixes or optimizations
-- Specific expertise needed
-- Learning/exploration
-
+### 🎯 Smart Discovery Before Creation
 ```bash
-# Good: Focused task
-snow-flow sparc frontend "fix mobile responsiveness issue"
-
-# Good: Specific expertise
-snow-flow sparc security "review permissions for table X"
-```
-
-#### **Team Coordination Guidelines**
+# Always check first!
+snow-flow swarm "find existing incident widgets and create improved version"
 
-1. **Let the Architect Lead**: Team coordinators (architects) analyze requirements and manage specialists
-2. **Enable Shared Memory**: Always use `--shared-memory` for complex tasks
-3. **Use Quality Gates**: Enable `--validation` for production deployments
-4. **Monitor Progress**: Use `--monitor` for long-running team tasks
-5. **Dry Run First**: Use `--dry-run` to preview team assembly for complex tasks
-
-#### **Error Handling and Recovery**
-
-Teams include automatic error recovery:
-- **Quality Gate Failures**: Automatic retry with specialist feedback
-- **Specialist Errors**: Fallback to alternative approaches
-- **Dependency Issues**: Intelligent rescheduling and re-coordination
-- **Shared Memory Conflicts**: Version control and conflict resolution
-
-### Migration from Old Agent System
-
-**Old Command → New Team Command:**
-```bash
-# Old: Monolithic approach
-snow-flow sparc coder "create widget" 
-# New: Specialized team
-snow-flow sparc team widget "create widget"
-
-# Old: Generic development
-snow-flow sparc designer "create flow"
-# New: Process-focused team  
-snow-flow sparc team flow "create flow"
-
-# Old: Single agent application
-snow-flow sparc architect "design app"
-# New: Full development team
-snow-flow sparc team app "design app"
+# Uses: snow_comprehensive_search() → swarm analysis → smart reuse recommendations
 ```
 
-**Backward Compatibility:**
-- All existing individual SPARC modes still work
-- Old commands automatically suggest team alternatives
-- Gradual migration path available
+## 🔧 Build Commands & Testing
+- `npm run build`: Build project  
+- `npm run test`: Run test suite
+- `npm run lint`: Code quality checks
+- `npm run typecheck`: TypeScript validation
+- `snow-flow auth login`: ServiceNow authentication
+- `snow-flow status`: System health check
 
-## 🎯 Quick Start Workflows
+## 💡 Important Development Rules
 
-### 🚀 Advanced Development Approaches
+### ✅ DO THESE ALWAYS:
+- ✅ **Start with MCP tools** - `snow_validate_live_connection()` first
+- ✅ **Use discovery** - `snow_find_artifact()` before creating  
+- ✅ **Deploy real artifacts** - `snow_deploy()` to ServiceNow
+- ✅ **Track everything** - Automatic in `snow_deploy()` with `auto_update_set: true`
+- ✅ **Test with mock data** - `snow_test_flow_with_mock()` for safety
 
-#### Team-Based Development (v1.1.62+)
+### ❌ NEVER DO THESE:
+- ❌ **Create local files** without MCP check first
+- ❌ **Generate mock sys_ids** instead of real deployment
+- ❌ **Skip authentication** validation  
+- ❌ **Work offline** when ServiceNow is available
+- ❌ **Ignore discovery** results
 
-```bash
-# Widget Development Team
-snow-flow sparc team widget "create incident dashboard"
+## 🚀 System Architecture
 
-# Flow Development Team  
-snow-flow sparc team flow "build approval workflow"
+Snow-flow is built on **MCP-native architecture**:
 
-# Application Development Team
-snow-flow sparc team app "create ITSM solution"
+1. **BaseMCPServer Pattern**: All 11 MCP servers use consistent error handling
+2. **MCPExecutionBridge**: Queen Agent uses real MCP tools, not mocks  
+3. **Smart Update Sets**: Automatic artifact tracking and management
+4. **Authentication-First**: Every operation validates ServiceNow access
+5. **Discovery-Driven**: Prevent duplication through intelligent search
 
-# Adaptive Team (for custom/unknown tasks)
-snow-flow sparc team adaptive "create complex integration"
+---
 
-# Individual Specialists
-snow-flow sparc frontend "mobile responsiveness"
-snow-flow sparc backend "API optimization"  
-snow-flow sparc security "access control review"
-```
+**Remember: Snow-flow's value is REAL ServiceNow integration. Always use `snow-flow swarm` with MCP tools first!** 🚀
 
-### 🎯 Quick Start Comparison
+## 🎯 PRIMARY COMMAND: snow-flow swarm
 
-#### **👑 RECOMMENDED: Queen Agent (Primary)**
-```bash
-# 1-3: Same setup
-# 4. Queen does everything automatically!
-snow-flow queen "create incident management widget"
-```
+**The `swarm` command is your main interface - it orchestrates everything MCP-first:**
 
-#### **🤖 Alternative: Enhanced Swarm**
 ```bash
-# 4. Use Queen intelligence with swarm
-snow-flow swarm "create widget" --queen
-```
+# ✅ PRIMARY INTERFACE - Use this!
+snow-flow swarm "create incident dashboard widget"
+snow-flow swarm "build approval workflow for equipment requests"
+snow-flow swarm "deploy mobile-responsive widget with accessibility features"
 
-#### **⚙️ Traditional: Team-Based**
-```bash
-# 4. Manual team coordination
-snow-flow sparc team widget "create dashboard"
+# ✅ All swarm operations automatically include:
+# 1. snow_validate_live_connection() - Auth check
+# 2. snow_comprehensive_search() - Smart discovery  
+# 3. snow_deploy() - Real ServiceNow deployment
+# 4. snow_update_set_add_artifact() - Automatic tracking
 ```
 
-## 💡 Important Notes
-
-### Do's
-- ✅ Use TodoWrite extensively for task tracking
-- ✅ Batch MCP tool calls for performance
-- ✅ Store important data in Memory for coordination
-- ✅ Test with mock data before deploying
-- ✅ Work within Update Sets for safety
-- ✅ Use fuzzy search for finding artifacts
-- ✅ Write out code thats important for the whole objective to work
-
-### Don'ts
-- ❌ Don't make sequential tool calls when batch is possible
-- ❌ Don't hardcode credentials or sys_ids
-- ❌ Don't deploy without testing
-- ❌ Don't ignore OAuth permission errors
-- ❌ Don't create artifacts without checking if they exist
-- ❌ Don't use mock data or placeholder code
-
-## 🚀 Performance Benchmarks
-
-With concurrent execution and batch operations:
-- **Widget Development**: 3x faster than sequential
-- **Flow Creation**: 2.5x faster with parallel validation
-- **Bulk Deployment**: Up to 5x faster with parallel mode
-- **Search Operations**: 4x faster with concurrent queries
-
----
-
-## 📚 Advanced Reference (MCP Tools & Traditional Approaches)
-
-*Note: The sections below contain advanced MCP tools and traditional approaches. For most users, the Queen Agent above is the recommended primary interface.*
-
-### MCP Server Documentation
-- **servicenow-deployment**: Widget, flow, and application deployment
-- **servicenow-intelligent**: Smart search and artifact discovery
-- **servicenow-operations**: Incident management and catalog operations
-- **servicenow-flow-composer**: Natural language flow creation
-- **servicenow-platform-development**: Scripts, rules, and policies
-
-### SPARC Modes
-
-#### **Individual SPARC Modes**
-- `orchestrator`: Coordinates complex multi-step tasks
-- `coder`: Focused code implementation
-- `researcher`: Deep analysis and discovery
-- `tester`: Comprehensive testing strategies
-- `architect`: System design and architecture
-
-#### **Team SPARC Modes (v1.1.62+)**
-- `team widget`: Widget development with Frontend + Backend + UI/UX + Platform + QA specialists
-- `team flow`: Flow development with Process + Trigger + Data + Integration + Security specialists
-- `team app`: Application development with Database + Business Logic + Interface + Security + Performance specialists
-- `team adaptive`: Dynamic team assembly based on task requirements
-
-#### **Individual Specialist Modes (v1.1.62+)**
-- `frontend`: HTML templates, CSS styling, responsive design
-- `backend`: Server scripts, API calls, data processing, performance optimization
-- `security`: Access controls, permissions, vulnerability assessment, compliance review
-- `data`: Database design, table relationships, data transformations
-- `integration`: APIs, external systems, data synchronization
-
----
-
-*This configuration ensures optimal use of Claude Code's batch tools for Snow-Flow ServiceNow development with maximum efficiency and safety.*
+**Every swarm operation is MCP-native and ServiceNow-first!** 🐝