snow-flow 8.38.0 → 8.38.2

package/dist/cli.js

@@ -420,17 +420,11 @@ program
             updateLearning: async () => { }
         };
     }
-    // Start SnowCode multi-agent orchestration
+    // Start SnowCode with the objective
     try {
-        // Generate the orchestration prompt
-        const orchestrationPrompt = buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated, sessionId);
         if (options.verbose) {
-            cliLogger.info('\n👑 Initializing multi-agent orchestration with SnowCode...');
-            cliLogger.info('🎯 SnowCode will coordinate the following:');
-            cliLogger.info(`   - Analyze objective: "${objective}"`);
-            cliLogger.info(`   - Spawn ${taskAnalysis.estimatedAgentCount} specialized agents via Task() system`);
-            cliLogger.info(`   - Coordinate through shared memory (session: ${sessionId})`);
-            cliLogger.info(`   - Monitor progress and adapt strategy`);
+            cliLogger.info('\n🚀 Starting SnowCode...');
+            cliLogger.info(`📋 Objective: "${objective}"`);
         }
         // Check if intelligent features are enabled
         const hasIntelligentFeatures = options.autoPermissions || options.smartDiscovery ||
@@ -574,9 +568,10 @@ async function executeSnowCode(objective, options) {
             cliLogger.error('SnowCode CLI not found - install: npm install -g @groeimetai/snow-code');
             return false;
         }
-        // Check for SnowCode config (.snow-code/snow-code.json)
-        const snowcodeConfigPath = (0, path_1.join)(process.cwd(), '.snow-code', 'snow-code.json');
-        if (!(0, fs_2.existsSync)(snowcodeConfigPath)) {
+        // Check for SnowCode config (.snow-code/config.json OR .snow-code/snow-code.json)
+        const snowcodeConfigPath = (0, path_1.join)(process.cwd(), '.snow-code', 'config.json');
+        const snowcodeConfigPathAlt = (0, path_1.join)(process.cwd(), '.snow-code', 'snow-code.json');
+        if (!(0, fs_2.existsSync)(snowcodeConfigPath) && !(0, fs_2.existsSync)(snowcodeConfigPathAlt)) {
             cliLogger.error('SnowCode config not found - run: snow-flow init');
             return false;
         }
@@ -675,594 +670,6 @@ async function executeSnowCode(objective, options) {
         return false;
     }
 }
-// Helper function to build Queen Agent orchestration prompt
-// Helper function to build Queen Agent orchestration prompt - CLEANED UP VERSION
-function buildQueenAgentPrompt(objective, taskAnalysis, options, isAuthenticated = false, sessionId) {
-    // Check if intelligent features are enabled
-    const hasIntelligentFeatures = options.autoPermissions || options.smartDiscovery ||
-        options.liveTesting || options.autoDeploy || options.autoRollback ||
-        options.sharedMemory || options.progressMonitoring;
-    const prompt = `# 👑 Snow-Flow Queen Agent Orchestration
-
-## 🤖 Claude Agent SDK Integration
-**Snow-Flow v5.0+ is powered by @anthropic-ai/claude-agent-sdk@0.1.1**
-
-This session uses the official Anthropic Claude Agent SDK for:
-- **MCP Server Management**: 2 unified servers with 411 tools automatically managed
-- **Agent Lifecycle**: SDK handles agent spawning, coordination, and resource optimization
-- **Intelligent Routing**: Task-aware tool routing and context management
-- **Performance Optimization**: Automatic batching and parallel execution support
-
-**Available Tools:**
-- **ServiceNow Unified Server** (235+ tools): All ServiceNow operations
-- **Snow-Flow Orchestration Server** (176+ tools): Swarm coordination, neural networks, memory
-
-## 🚨 CRITICAL: PREVENT INFINITE LOOPS - READ FIRST!
-
-**NEVER SPAWN DUPLICATE AGENTS!** This causes infinite loops that spam MCP servers and crash Codespaces!
-
-**❌ INFINITE LOOP PATTERN (PROHIBITED):**
-\`\`\`
-Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
-Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE AGENT TYPE!
-Task(\"Workspace Tools Tester\", \"Test workspace tools\");
-Task(\"Workspace Tools Tester\", \"Test workspace tools\");  // ← INFINITE LOOP!
-\`\`\`
-
-**✅ CORRECT PATTERN (REQUIRED):**
-\`\`\`
-Task(\"workspace-architect\", \"Create ONE UX workspace using snow_create_complete_workspace\");
-Task(\"ui-designer\", \"Design UI components AFTER workspace is created\");
-Task(\"validator\", \"Test AFTER both previous agents complete\");
-\`\`\`
-
-**GOLDEN RULES:**
-1. **ONE agent per task type maximum**
-2. **UNIQUE agent names** (not generic \"Tester\")
-3. **SEQUENTIAL spawning** - wait for completion
-4. **CHECK Memory** for existing agents first
-
-## 🎯 Mission Brief
-You are the Queen Agent, master coordinator of the Snow-Flow hive-mind. Your mission is to orchestrate a swarm of specialized agents to complete the following ServiceNow development objective:
-
-**Objective**: ${objective}
-**Session ID**: ${sessionId}
-
-## 🧠 Task Analysis Summary
-- **Task Type**: ${taskAnalysis.taskType}
-- **Complexity**: ${taskAnalysis.complexity}
-- **Primary Agent Required**: ${taskAnalysis.primaryAgent}
-- **Supporting Agents**: ${taskAnalysis.supportingAgents.join(', ')}
-- **Estimated Total Agents**: ${taskAnalysis.estimatedAgentCount}
-- **ServiceNow Artifacts**: ${taskAnalysis.serviceNowArtifacts.join(', ')}
-
-## ⚡ CRITICAL: Task Intent Analysis
-**BEFORE PROCEEDING**, analyze the user's ACTUAL intent:
-
-1. **Data Generation Request?** (e.g., "create 5000 incidents", "generate test data")
-   → Focus on CREATING DATA, not building systems
-   → Use simple scripts or bulk operations to generate the data
-   → Skip complex architectures unless explicitly asked
-
-2. **System Building Request?** (e.g., "build a widget", "create an ML system")
-   → Follow full development workflow
-   → Build proper architecture and components
-
-3. **Simple Operation Request?** (e.g., "update field X", "delete records")
-   → Execute the operation directly
-   → Skip unnecessary complexity
-
-**For this objective**: Analyze if the user wants data generation, system building, or a simple operation.
-
-## 📊 Table Discovery Intelligence
-
-The Queen Agent will automatically discover and validate table schemas based on the objective. This ensures agents use correct field names and table structures.
-
-**Table Detection Examples:**
-- "create widget for incident records" → Discovers: incident, sys_user, sys_user_group
-- "build catalog item for equipment requests" → Discovers: sc_cat_item, sc_category, u_equipment_request
-- "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
-
-**Discovery Process:**
-1. Extracts table names from objective (standard tables, u_ custom tables, explicit mentions)
-2. Discovers actual table schemas with field names, types, and relationships
-3. Stores schemas in memory for all agents to use
-4. Agents MUST use exact field names from schemas (e.g., 'short_description' not 'desc')
-
-## 👑 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"):
-
-1. **DO NOT** build complex export/import systems
-2. **DO NOT** create APIs, UI Actions, or workflows
-3. **DO** focus on:
-   - Creating a simple script to generate the data
-   - Using ServiceNow's REST API or direct table operations
-   - Ensuring realistic data distribution for ML training
-   - Adding variety in categories, priorities, descriptions, etc.
-
-**Example approach for "create 5000 incidents":**
-\`\`\`javascript
-// Simple batch creation script
-for (let i = 0; i < 5000; i += 100) {
-  // Create 100 incidents at a time to avoid timeouts
-  const batch = generateRealisticIncidentBatch(100);
-  await createIncidentsBatch(batch);
-}
-\`\`\`
-
-### 1. Initialize Memory & Session (Required First Step)
-**THIS MUST BE YOUR VERY FIRST ACTION:**
-\`\`\`javascript
-// Initialize swarm memory session using memory_usage MCP tool
-await memory_usage({
-  action: 'store',
-  key: "swarm_session_${sessionId}",
-  value: JSON.stringify({
-    objective: "${objective}",
-    status: "initializing",
-    started_at: new Date().toISOString(),
-    task_analysis: ${JSON.stringify(taskAnalysis, null, 2)},
-    configuration: {
-      strategy: "${options.strategy}",
-      mode: "${options.mode}",
-      max_agents: ${parseInt(options.maxAgents)},
-      authenticated: ${isAuthenticated}
-    }
-  })
-});
-\`\`\`
-
-### 2. 🚨 MANDATORY: ServiceNow Auth & Update Set Setup
-**CRITICAL: These steps are REQUIRED for ALL development work:**
-
-\`\`\`javascript
-// Step 2.1: MANDATORY - Test ServiceNow authentication
-const authCheck = await snow_auth_diagnostics();
-if (!authCheck.success) {
-  throw new Error("❌ CRITICAL: Authentication failed! Run: snow-flow auth login");
-}
-
-// Step 2.2: MANDATORY - Create Update Set for tracking ALL changes
-const updateSetName = "Snow-Flow: ${objective.substring(0, 50)}... - ${new Date().toISOString().split('T')[0]}";
-const updateSet = await snow_update_set_create({
-  name: updateSetName,
-  description: "Automated Snow-Flow development for: ${objective}\\n\\nSession: ${sessionId}\\nAll changes tracked automatically",
-  auto_switch: true  // 🚨 CRITICAL: Sets as current update set!
-});
-
-// Store Update Set info in memory for all agents using memory_usage MCP tool
-await memory_usage({
-  action: 'store',
-  key: "update_set_${sessionId}",
-  value: JSON.stringify(updateSet)
-});
-await memory_usage({
-  action: 'store',
-  key: "current_update_set",
-  value: updateSet.sys_id
-});
-\`\`\`
-
-**WHY THIS IS CRITICAL:**
-- ✅ All ServiceNow changes are automatically tracked
-- ✅ Enables deployment to other instances later  
-- ✅ Provides rollback capabilities
-- ✅ Follows ServiceNow development best practices
-- ❌ **WITHOUT UPDATE SET: Changes are untracked and risky!**
-
-### 3. Create Master Task List
-After completing setup steps, create task breakdown:
-\`\`\`javascript
-TodoWrite([
-  {
-    id: "setup_complete",
-    content: "✅ Setup: Auth, Update Set, Memory initialized",
-    status: "completed",
-    priority: "high"
-  },
-  {
-    id: "analyze_requirements",
-    content: "Analyze user requirements: ${objective}",
-    status: "in_progress",
-    priority: "high"
-  },
-  {
-    id: "spawn_agents",
-    content: "Spawn ${taskAnalysis.estimatedAgentCount} specialized agents",
-    status: "pending",
-    priority: "high"
-  },
-  {
-    id: "coordinate_development",
-    content: "Coordinate agent activities for ${taskAnalysis.taskType}",
-    status: "pending",
-    priority: "high"
-  },
-  {
-    id: "validate_solution",
-    content: "Validate and test the complete solution",
-    status: "pending",
-    priority: "medium"
-  }
-]);
-\`\`\`
-
-### 4. Agent Spawning Strategy - 🚨 ANTI-LOOP PROTECTION 🚨
-
-**CRITICAL: NO DUPLICATE AGENTS! ONLY SPAWN EACH AGENT TYPE ONCE!**
-
-**✅ CORRECT (Single Agents Only):**
-1. **Initialize Swarm ONCE**: \`swarm_init({ topology: 'hierarchical', maxAgents: ${parseInt(options.maxAgents)} })\`
-2. **Spawn ${taskAnalysis.estimatedAgentCount} DIFFERENT agents**: 
-Spawn ONE agent of each required type based on the objective:
-
-**${taskAnalysis.taskType} requires these UNIQUE agents:**
-- **ONE researcher**: \`Task(\"researcher\", \"Research ServiceNow requirements for: ${objective}\")\`
-- **ONE ${taskAnalysis.primaryAgent}**: \`Task(\"${taskAnalysis.primaryAgent}\", \"Implement main solution for: ${objective}\")\`
-- **ONE tester**: \`Task(\"tester\", \"Test and validate solution for: ${objective}\")\`
-
-**🚨 CRITICAL ANTI-LOOP RULES:**
-- **NEVER spawn multiple agents of the same type**
-- **NEVER spawn \"UI Builder Tools Tester\" multiple times**
-- **NEVER spawn \"Workspace Tools Tester\" multiple times**
-- **WAIT for agent completion** before spawning related agents
-- **CHECK Memory** for existing agents before spawning new ones
-
-**❌ PROHIBITED PATTERNS:**
-\`\`\`
-// DON'T DO THIS - CAUSES INFINITE LOOPS:
-Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");
-Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← DUPLICATE!
-Task(\"UI Builder Tools Tester\", \"Test UI Builder tools\");  // ← INFINITE LOOP!
-\`\`\`
-
-**✅ CORRECT PATTERNS:**
-\`\`\`
-// DO THIS - SINGLE AGENTS WITH SPECIFIC TASKS:
-Task(\"ui-builder-specialist\", \"Create specific UI Builder page for incident management\");
-Task(\"workspace-architect\", \"Design UX workspace structure for IT support team\");
-Task(\"testing-specialist\", \"Validate workspace functionality and report results\");
-\`\`\`
-
-### 5. Memory Coordination Pattern with Loop Detection
-All agents MUST use this memory coordination WITH loop prevention:
-
-\`\`\`javascript
-// STEP 1: Check if agent type already exists (PREVENT LOOPS!)
-const existingAgentsResult = await memory_usage({
-  action: 'retrieve',
-  key: 'active_agents'
-});
-const existingAgents = existingAgentsResult?.value ? JSON.parse(existingAgentsResult.value) : [];
-const agentType = 'ui-builder-specialist';
-
-if (existingAgents.includes(agentType)) {
-  console.log('Agent type already active - SKIPPING to prevent infinite loop');
-  return; // DON'T spawn duplicate agents!
-}
-
-// STEP 2: Register agent as active
-const agentId = \`agent_\${agentType}_\${sessionId}\`;
-existingAgents.push(agentType);
-await memory_usage({
-  action: 'store',
-  key: 'active_agents',
-  value: JSON.stringify(existingAgents)
-});
-
-// STEP 3: Agent stores progress
-await memory_usage({
-  action: 'store',
-  key: \`\${agentId}_progress\`,
-  value: JSON.stringify({
-    agent_type: agentType,
-    status: "working",
-    current_task: "description of current work",
-    completion_percentage: 45,
-    spawned_at: new Date().toISOString(),
-    last_update: new Date().toISOString()
-  })
-});
-
-// Agent reads other agent's work when needed
-const primaryWorkResult = await memory_usage({
-  action: 'retrieve',
-  key: "agent_\${taskAnalysis.primaryAgent}_output"
-});
-const primaryWork = primaryWorkResult?.value ? JSON.parse(primaryWorkResult.value) : null;
-
-// Agent signals completion
-await memory_usage({
-  action: 'store',
-  key: \`\${agentId}_complete\`,
-  value: JSON.stringify({
-    completed_at: new Date().toISOString(),
-    outputs: { /* agent deliverables */ },
-    artifacts_created: [ /* list of created artifacts */ ]
-  })
-});
-\`\`\`
-
-## 🧠 Intelligent Features Configuration
-${hasIntelligentFeatures ? `✅ **INTELLIGENT MODE ACTIVE** - The following features are enabled:
-
-- **🔐 Auto Permissions**: ${options.autoPermissions ? '✅ Will escalate permissions automatically' : '❌ Manual permission handling'}
-- **🔍 Smart Discovery**: ${options.smartDiscovery ? '✅ Will discover and reuse existing artifacts' : '❌ Create all new artifacts'}
-- **🧪 Live Testing**: ${options.liveTesting ? '✅ Will test in real ServiceNow instance' : '❌ Local testing only'}
-- **🚀 Auto Deploy**: ${options.autoDeploy ? '⚠️ WILL DEPLOY TO SERVICENOW AUTOMATICALLY' : '✅ Planning mode - no deployment'}
-- **🔄 Auto Rollback**: ${options.autoRollback ? '✅ Will rollback on any failures' : '❌ No automatic rollback'}
-- **💾 Shared Memory**: ${options.sharedMemory ? '✅ Agents share context via Memory' : '❌ Isolated agent execution'}
-- **📊 Progress Monitoring**: ${options.progressMonitoring ? '✅ Real-time progress tracking' : '❌ No progress monitoring'}
-- **📝 Script Execution**: ${options.autoConfirm ? '⚠️ AUTO-CONFIRM - Background scripts execute without user confirmation' : options.autoConfirm === false ? '🔒 FORCE CONFIRM - Always ask for script confirmation' : '🤚 DEFAULT - Ask for confirmation on risky scripts'}` : '❌ **STANDARD MODE** - Use manual coordination patterns'}
-
-## 🎯 ServiceNow Execution Strategy
-
-### 🚀 MANDATORY: Live ServiceNow Development First!
-
-**CRITICAL RULE**: All agents MUST attempt to use ServiceNow MCP tools first, regardless of authentication status.
-
-### 🚨 MANDATORY: ES5 JavaScript Only for ALL ServiceNow Scripts
-**⚠️ SERVICENOW RHINO ENGINE = ES5 ONLY - NO MODERN SYNTAX!**
-
-**CRITICAL ES5 RULES:**
-- NO const/let (use var)
-- NO arrow functions (use function())
-- NO template literals (use string concatenation) 
-- NO destructuring (use explicit property access)
-- NO for...of loops (use traditional for loops)
-- NO default parameters (use typeof checks)
-
-**🔥 If you use ES6+ syntax, the script WILL FAIL with SyntaxError!**
-**See CLAUDE.md for complete ES5 examples and common mistake fixes.**
-
-### 📝 Background Script Execution Settings
-${options.autoConfirm ? '⚠️ **AUTO-CONFIRM MODE ENABLED**: When calling snow_execute_background_script, ALWAYS add autoConfirm: true parameter to skip user confirmation.\n```javascript\nsnow_execute_background_script({\n  script: "your ES5 script here",\n  description: "Clear description",\n  autoConfirm: true  // ⚠️ User enabled auto-confirm mode\n})\n```' : options.autoConfirm === false ? '🔒 **FORCE CONFIRM MODE**: All background scripts will require user confirmation, even simple ones.' : '🤚 **DEFAULT MODE**: Background scripts will ask for user confirmation based on risk level.'}
-
-#### Current MCP Tools Available (Snow-Flow v3.3.4)
-${isAuthenticated ? '✅ Authentication detected - full deployment capabilities' : '⚠️ No authentication detected - MCP tools will provide specific instructions if auth needed'}
-
-Your agents MUST use these MCP tools IN THIS ORDER:
-
-🚨 **MANDATORY PRE-FLIGHT CHECKS** (ALWAYS do first!):
-1. \`snow_auth_diagnostics\` - Test authentication and permissions
-2. \`snow_update_set_create\` - Create and activate update set for tracking
-3. If auth fails, STOP and provide instructions to run 'snow-flow auth login'
-4. If update set fails, STOP - development work is not safe without tracking
-
-🎯 **Core Development Tools**:
-1. **Universal Query Tool**: \`snow_query_table\` - Works with ALL ServiceNow tables
-   - Count-only: \`{table: "incident", query: "state!=7"}\` → Memory efficient
-   - Specific fields: \`{table: "sc_request", fields: ["number", "state"]}\` → Only needed data
-   - Full content: \`{table: "change_request", include_content: true}\` → When all data needed
-
-2. **Deployment Tools**: 
-   - \`snow_deploy\` - Universal deployment for NEW artifacts (16+ types supported!)
-   - \`snow_update\` - Update EXISTING artifacts by name or sys_id
-
-3. **Discovery Tools**:
-   - \`snow_discover_table_fields\` - Get exact field names and types
-   - \`snow_table_schema_discovery\` - Complete table structure
-
-4. **Update Set Management**:
-   - \`snow_update_set_create\` - Create new update sets
-   - \`snow_update_set_add_comment\` - Track progress
-   - \`snow_update_set_retrieve\` - Get update set XML
-
-## 🔧 NEW: Expanded Artifact Support (v3.3.4)
-
-Snow-Flow now supports **16+ different ServiceNow artifact types**:
-
-| Type | Table | Deploy | Update | Natural Language |
-|------|-------|--------|---------|------------------|
-| widget | sp_widget | ✅ | ✅ | ✅ |
-| business_rule | sys_script | ✅ | ✅ | ✅ |
-| script_include | sys_script_include | ✅ | ✅ | ✅ |
-| ui_page | sys_ui_page | ✅ | ✅ | ✅ |
-| client_script | sys_script_client | ✅ | ✅ | ✅ |
-| ui_action | sys_ui_action | ✅ | ✅ | ✅ |
-| ui_policy | sys_ui_policy | ✅ | ✅ | ✅ |
-| acl | sys_security_acl | ✅ | ✅ | ✅ |
-| table | sys_db_object | ✅ | ✅ | ✅ |
-| field | sys_dictionary | ✅ | ✅ | ✅ |
-| workflow | wf_workflow | ✅ | ✅ | ✅ |
-| flow | sys_hub_flow | ✅ | ✅ | ✅ |
-| notification | sysevent_email_action | ✅ | ✅ | ✅ |
-| scheduled_job | sysauto_script | ✅ | ✅ | ✅ |
-
-**Usage Examples:**
-\`\`\`javascript
-// Deploy NEW artifacts
-await snow_deploy({
-  type: 'business_rule',
-  name: 'Auto Assignment Rule',
-  table: 'incident',
-  when: 'before',
-  script: 'if (current.priority == "1") current.assigned_to = "admin";'
-});
-
-// Update EXISTING artifacts (natural language supported!)
-await snow_update({
-  type: 'ui_action',
-  identifier: 'close_incident',
-  instruction: 'Change label to "Close with Resolution" and add validation'
-});
-\`\`\`
-
-${options.autoDeploy ? `
-#### ⚠️ AUTO-DEPLOYMENT ACTIVE ⚠️
-- Real artifacts will be created in ServiceNow
-- All changes tracked in Update Sets
-- Rollback available if needed
-` : `
-#### 📋 Planning Mode Active
-- No real artifacts will be created
-- Analysis and recommendations only
-- Use --auto-deploy to enable deployment
-`}
-
-${!isAuthenticated ? `### ❌ ServiceNow Integration Disabled
-
-#### Planning Mode (Auth Required)
-When authentication is not available, agents will:
-1. Document the COMPLETE solution architecture
-2. Create detailed implementation guides
-3. Store all plans in Memory for future deployment
-4. Provide SPECIFIC instructions: "Run snow-flow auth login"
-
-⚠️ IMPORTANT: This is a FALLBACK mode only!
-Agents must ALWAYS try MCP tools first!` : ''}
-
-## 👑 Queen Agent Coordination Instructions
-
-### 6. Agent Coordination & Handoffs
-Ensure smooth transitions between agents:
-
-\`\`\`javascript
-// Primary agent signals readiness for support
-await memory_usage({
-  action: 'store',
-  key: "agent_${taskAnalysis.primaryAgent}_ready_for_support",
-  value: JSON.stringify({
-    base_structure_complete: true,
-    ready_for: [${taskAnalysis.supportingAgents.map(a => `"${a}"`).join(', ')}],
-    timestamp: new Date().toISOString()
-  })
-});
-
-// Supporting agents check readiness
-const readinessResult = await memory_usage({
-  action: 'retrieve',
-  key: "agent_${taskAnalysis.primaryAgent}_ready_for_support"
-});
-const canProceed = readinessResult?.value ? JSON.parse(readinessResult.value) : {};
-if (canProceed?.base_structure_complete) {
-  // Begin supporting work
-}
-\`\`\`
-
-### 7. Final Validation and Completion
-Once all agents complete their work:
-
-\`\`\`javascript
-// Collect all agent outputs
-const agentOutputs = {};
-const agents = [${[taskAnalysis.primaryAgent, ...taskAnalysis.supportingAgents].map(a => `"${a}"`).join(', ')}];
-
-for (const agent of agents) {
-  const outputResult = await memory_usage({
-    action: 'retrieve',
-    key: \`agent_\${agent}_complete\`
-  });
-  if (outputResult?.value) {
-    agentOutputs[agent] = JSON.parse(outputResult.value);
-  }
-}
-
-// Store final swarm results
-await memory_usage({
-  action: 'store',
-  key: "swarm_session_${sessionId}_results",
-  value: JSON.stringify({
-    objective: "${objective}",
-    completed_at: new Date().toISOString(),
-    agent_outputs: agentOutputs,
-    artifacts_created: Object.values(agentOutputs)
-      .flatMap(output => output.artifacts_created || []),
-    success: true
-  })
-});
-
-// Update final TodoWrite status
-TodoWrite([
-  {
-    id: "swarm_completion",
-    content: "Swarm successfully completed: ${objective}",
-    status: "completed",
-    priority: "high"
-  }
-]);
-\`\`\`
-
-## 🎯 Success Criteria
-
-Your Queen Agent orchestration is successful when:
-1. ✅ All agents have been spawned and initialized
-2. ✅ Swarm session is tracked in Memory
-3. ✅ Agents are coordinating through shared Memory
-4. ✅ TodoWrite is being used for task tracking
-5. ✅ ${taskAnalysis.taskType} requirements are met
-6. ✅ All artifacts are created/deployed successfully
-
-## 💡 Queen Agent Best Practices
-
-### **Workflow Orchestration:**
-1. **NEVER parallel foundation work** - research, planning, architecture must be sequential
-2. **Foundation → Development → Validation** - strict phase progression  
-3. **Parallel development only** after foundation complete
-4. **Use Memory to share foundation outputs** to development agents
-5. **Coordinate parallel agents** through shared Memory state
-
-### **Agent Coordination:**
-1. **Sequential Agents**: researcher → planner → architect (must wait for each other)
-2. **Parallel Agents**: widget-developer + script-writer + ui-builder (can work simultaneously)
-3. **Foundation Dependencies**: All development agents depend on architecture completion
-4. **Shared Memory**: Store research findings, plans, architecture for all agents to access
-
-### **Task Management:**
-1. **Update TodoWrite** with phase progression
-2. **Mark foundation complete** before starting development  
-3. **Monitor parallel agent progress** and coordinate conflicts
-4. **Validate outputs** before marking complete
-5. **Store all decisions** in Memory for audit trail
-
-### **Example Workflow:**
-**Phase 1 (Sequential):** researcher → architect → planner
-**Phase 2 (Parallel):** widget-dev + script-writer + ui-builder (use foundation outputs)  
-**Phase 3 (Parallel):** tester + reviewer + documenter (validate development outputs)
-
-## 🚀 Begin Orchestration
-
-Now execute this Queen Agent orchestration plan:
-1. Initialize the swarm session in Memory
-2. Create the master task list with TodoWrite
-3. Spawn all required agents using Task
-4. Monitor progress and coordinate
-5. Validate and complete the objective
-
-Remember: You are the Queen Agent - the master coordinator. Your role is to ensure all agents work harmoniously to achieve the objective: "${objective}"
-
-## 📊 Session Information
-- **Session ID**: ${sessionId}
-- **Snow-Flow Version**: v${version_js_1.VERSION}
-- **Authentication**: ${isAuthenticated ? 'Active' : 'Required'}
-- **Deployment Mode**: ${options.autoDeploy ? 'Live deployment enabled' : 'Planning mode'}
-- **Estimated Agents**: ${taskAnalysis.estimatedAgentCount}
-- **Primary Agent**: ${taskAnalysis.primaryAgent}
-
-🎯 **Ready to begin orchestration!**
-`;
-    return prompt;
-}
 // Helper function to analyze objectives using intelligent agent detection
 function analyzeObjective(objective, userMaxAgents) {
     return agent_detector_js_1.AgentDetector.analyzeTask(objective, userMaxAgents);
@@ -1740,10 +1147,10 @@ async function checkAndInstallSnowCode() {
 }
 async function createDirectoryStructure(targetDir, force = false) {
     // Minimal directory structure for snow-code
-    // Legacy directories (.claude, .swarm, .snow-flow, memory, coordination, servicenow, templates, scripts) removed
+    // Legacy directories (.claude, .swarm, .snow-flow, memory, coordination, servicenow, templates, scripts, .snow-code/agent) removed
+    // snow-code has its own built-in agent system, no need for custom agents from snow-flow
     const directories = [
         '.snow-code',
-        '.snow-code/agent',
         '.snow-code/command',
         '.snow-code/plugin'
     ];
@@ -2010,16 +1417,16 @@ async function verifyMCPServers(targetDir) {
     const path = require('path');
     const fs = require('fs').promises;
     try {
-        // Read SnowCode configuration - try snow-code.json first (primary), then config.json (fallback)
-        const snowCodeJsonPath = path.join(targetDir, '.snow-code', 'snow-code.json');
+        // Read SnowCode configuration - try config.json first (primary), then snow-code.json (fallback for legacy)
         const configJsonPath = path.join(targetDir, '.snow-code', 'config.json');
+        const snowCodeJsonPath = path.join(targetDir, '.snow-code', 'snow-code.json');
         let configContent;
         try {
-            configContent = await fs.readFile(snowCodeJsonPath, 'utf-8');
+            configContent = await fs.readFile(configJsonPath, 'utf-8');
         }
         catch {
-            // Fallback to config.json if snow-code.json doesn't exist
-            configContent = await fs.readFile(configJsonPath, 'utf-8');
+            // Fallback to snow-code.json for legacy projects
+            configContent = await fs.readFile(snowCodeJsonPath, 'utf-8');
         }
         const config = JSON.parse(configContent);
         if (!config.mcp) {
@@ -2180,32 +1587,7 @@ async function copyCLAUDEmd(targetDir, force = false) {
         }
         // Setup .snow-code/ directory (directories already created by createDirectoryStructure)
         const snowcodeDir = (0, path_1.join)(targetDir, '.snow-code');
-        const agentsDir = (0, path_1.join)(snowcodeDir, 'agent');
-        // Copy agent files from .snow-code/agent/ in snow-flow package
-        const sourceAgentsDir = (0, path_1.join)(snowFlowRoot, '.snow-code', 'agent');
-        try {
-            const agentFiles = await fs_1.promises.readdir(sourceAgentsDir);
-            for (const file of agentFiles) {
-                if (file.endsWith('.md')) {
-                    const sourceFile = (0, path_1.join)(sourceAgentsDir, file);
-                    const targetFile = (0, path_1.join)(agentsDir, file);
-                    try {
-                        await fs_1.promises.access(targetFile);
-                        if (force) {
-                            const content = await fs_1.promises.readFile(sourceFile, 'utf-8');
-                            await fs_1.promises.writeFile(targetFile, content);
-                        }
-                    }
-                    catch {
-                        const content = await fs_1.promises.readFile(sourceFile, 'utf-8');
-                        await fs_1.promises.writeFile(targetFile, content);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            // Silently continue - agent files are optional
-        }
+        // Agent files no longer copied - snow-code has its own built-in agent system
         // Create .snow-code/config.json from .mcp.json.template
         const envPath = (0, path_1.join)(targetDir, '.env');
         const envValues = {};
@@ -2365,7 +1747,7 @@ async function appendToEnvFile(targetDir, content) {
 }
 /**
  * Converts Claude Desktop MCP config format to SnowCode/OpenCode format
- * Single source of truth: .mcp.json.template → both .mcp.json and .snow-code/snow-code.json
+ * Single source of truth: .mcp.json.template → both .mcp.json and .snow-code/config.json
  */
 function convertToSnowCodeFormat(claudeConfig) {
     const snowcodeConfig = {
@@ -2994,7 +2376,7 @@ async function setupMCPConfig(targetDir, instanceUrl, clientId, clientSecret, fo
         prompts.log.message(`   Servers: ${Object.keys(snowcodeConfig.mcp).join(', ')}`);
         // 🔥 ALSO write LOCAL config (takes priority!)
         const localSnowcodeDir = (0, path_1.join)(targetDir, '.snow-code');
-        const localSnowcodePath = (0, path_1.join)(localSnowcodeDir, 'snow-code.json');
+        const localSnowcodePath = (0, path_1.join)(localSnowcodeDir, 'config.json');
         try {
             // Ensure local .snow-code directory exists
             await fs_1.promises.mkdir(localSnowcodeDir, { recursive: true });