claude-flow 2.0.0-alpha.82 → 2.0.0-alpha.84

package/src/cli/index-remote.ts

@@ -4,7 +4,7 @@
  * This version can be run directly from GitHub
  */
 
-const VERSION = '2.0.0-alpha.81';
+const VERSION = '2.0.0-alpha.83';
 
 // Simple color functions
 const chalk = {

package/src/cli/index.ts

@@ -27,7 +27,7 @@ import { startREPL } from './repl.js';
 import { CompletionGenerator } from './completion.js';
 
 // Version information
-const VERSION = '2.0.0-alpha.81';
+const VERSION = '2.0.0-alpha.83';
 const BUILD_DATE = new Date().toISOString().split('T')[0];
 
 // Main CLI command

package/src/cli/simple-cli.js

@@ -27,7 +27,23 @@ import process from 'process';
 import readline from 'readline';
 import { getMainHelp, getCommandHelp, getStandardizedCommandHelp } from './help-text.js';
 
-const VERSION = '2.0.0-alpha.81';
+const VERSION = '2.0.0-alpha.83';
+
+// Legacy agent type mapping for backward compatibility
+const LEGACY_AGENT_MAPPING = {
+  analyst: 'code-analyzer',
+  coordinator: 'task-orchestrator', 
+  optimizer: 'perf-analyzer',
+  documenter: 'api-docs',
+  monitor: 'performance-benchmarker',
+  specialist: 'system-architect',
+  architect: 'system-architect',
+};
+
+// Resolve legacy agent types to current equivalents
+function resolveLegacyAgentType(legacyType) {
+  return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
+}
 
 function printHelp(plain = false) {
   console.log(getMainHelp(plain));
@@ -51,7 +67,7 @@ function printLegacyHelp() {
 🌊 Claude-Flow v${VERSION} - Enterprise-Grade AI Agent Orchestration Platform
 
 🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 90+ MCP tools, neural networking, and production-ready infrastructure
-⚡ ALPHA 81: Optimized for Claude Code 1.0.51+ with enhanced batch processing and concurrent execution
+⚡ ALPHA 83: Enhanced GitHub hooks with npx commands, improved checkpoint reliability, seamless CI/CD integration
 
 USAGE:
   claude-flow <command> [options]
@@ -331,12 +347,13 @@ async function main() {
 
     case 'spawn':
       // Convenience alias for agent spawn
-      const spawnType = subArgs[0] || 'general';
+      const rawSpawnType = subArgs[0] || 'general';
+      const spawnType = resolveLegacyAgentType(rawSpawnType);
       const spawnName = flags.name || `agent-${Date.now()}`;
 
       printSuccess(`Spawning ${spawnType} agent: ${spawnName}`);
       console.log('🤖 Agent would be created with the following configuration:');
-      console.log(`   Type: ${spawnType}`);
+      console.log(`   Type: ${spawnType}${rawSpawnType !== spawnType ? ` (resolved from: ${rawSpawnType})` : ''}`);
       console.log(`   Name: ${spawnName}`);
       console.log('   Capabilities: Research, Analysis, Code Generation');
       console.log('   Status: Ready');
@@ -2349,7 +2366,8 @@ Shortcuts:
     const subCmd = args[0];
     switch (subCmd) {
       case 'spawn':
-        const type = args[1] || 'researcher';
+        const rawType = args[1] || 'researcher';
+        const type = resolveLegacyAgentType(rawType);
         const name = args[2] || `agent-${Date.now()}`;
         const agent = {
           id: `agent-${Date.now()}`,

package/src/cli/simple-cli.ts

@@ -14,7 +14,7 @@ import {
 } from './command-registry.js';
 import { parseFlags } from './utils.js';
 
-const VERSION = '2.0.0-alpha.81';
+const VERSION = '2.0.0-alpha.83';
 
 function printHelp() {
   console.log(`

package/src/cli/simple-commands/hive-mind.js

@@ -1540,19 +1540,23 @@ async function listMemories() {
   try {
     console.log(chalk.blue('\n📋 Collective Memory Store\n'));
 
-    // Use MCP wrapper to search for all memories (empty pattern matches all)
-    const mcpWrapper = await getMcpWrapper();
-    const searchResult = await mcpWrapper.searchMemory('hive-mind', '');
+    // Read directly from hive.db collective_memory table
+    const dbPath = path.join(cwd(), '.hive-mind', 'hive.db');
+    const db = new Database(dbPath);
 
-    // Handle different possible response structures
-    let memories = [];
-    if (searchResult && Array.isArray(searchResult.results)) {
-      memories = searchResult.results;
-    } else if (searchResult && Array.isArray(searchResult)) {
-      memories = searchResult;
-    } else if (searchResult && searchResult.data && Array.isArray(searchResult.data)) {
-      memories = searchResult.data;
-    }
+    const memories = db
+      .prepare(
+        `
+        SELECT cm.*, s.name as swarm_name
+        FROM collective_memory cm
+        LEFT JOIN swarms s ON cm.swarm_id = s.id
+        ORDER BY cm.created_at DESC
+        LIMIT 50
+      `,
+      )
+      .all();
+
+    db.close();
 
     if (!memories || memories.length === 0) {
       console.log(chalk.yellow('No memories found in the collective store.'));
@@ -1562,15 +1566,34 @@ async function listMemories() {
       return;
     }
 
+    console.log(chalk.gray(`Found ${memories.length} memories in the collective store:\n`));
+
     memories.forEach((memory, index) => {
-      console.log(chalk.cyan(`${index + 1}. ${memory.key || `memory-${index}`}`));
-      console.log(`   Category: ${memory.type || 'general'}`);
-      console.log(`   Created: ${new Date(memory.timestamp || Date.now()).toLocaleString()}`);
-      if (memory.value && typeof memory.value === 'object') {
-        console.log(`   Preview: ${JSON.stringify(memory.value).substring(0, 100)}...`);
+      console.log(chalk.cyan(`${index + 1}. ${memory.key}`));
+      console.log(`   Swarm: ${memory.swarm_name || memory.swarm_id}`);
+      console.log(`   Type: ${memory.type || 'knowledge'}`);
+      console.log(`   Created: ${new Date(memory.created_at).toLocaleString()}`);
+      console.log(`   Created by: ${memory.created_by || 'system'}`);
+      
+      // Parse and display value
+      let displayValue = memory.value;
+      try {
+        const parsed = JSON.parse(memory.value);
+        displayValue = JSON.stringify(parsed);
+      } catch {
+        // Keep as string
+      }
+      
+      if (displayValue.length > 100) {
+        console.log(`   Value: ${displayValue.substring(0, 100)}...`);
       } else {
-        console.log(`   Value: ${String(memory.value || memory).substring(0, 100)}...`);
+        console.log(`   Value: ${displayValue}`);
       }
+      
+      if (memory.confidence !== null && memory.confidence !== 1) {
+        console.log(`   Confidence: ${(memory.confidence * 100).toFixed(1)}%`);
+      }
+      
       console.log('');
     });
   } catch (error) {
@@ -1595,29 +1618,49 @@ async function searchMemories() {
 
     console.log(chalk.blue(`\n🔍 Searching for: "${searchTerm}"\n`));
 
-    const mcpWrapper = await getMcpWrapper();
-    const searchResult = await mcpWrapper.searchMemory('hive-mind', searchTerm);
+    // Search directly in hive.db collective_memory table
+    const dbPath = path.join(cwd(), '.hive-mind', 'hive.db');
+    const db = new Database(dbPath);
 
-    // Handle different possible response structures
-    let memories = [];
-    if (searchResult && Array.isArray(searchResult.results)) {
-      memories = searchResult.results;
-    } else if (searchResult && Array.isArray(searchResult)) {
-      memories = searchResult;
-    } else if (searchResult && searchResult.data && Array.isArray(searchResult.data)) {
-      memories = searchResult.data;
-    }
+    const searchPattern = `%${searchTerm}%`;
+    const memories = db
+      .prepare(
+        `
+        SELECT cm.*, s.name as swarm_name
+        FROM collective_memory cm
+        LEFT JOIN swarms s ON cm.swarm_id = s.id
+        WHERE cm.key LIKE ? OR cm.value LIKE ? OR cm.type LIKE ?
+        ORDER BY cm.created_at DESC
+        LIMIT 50
+      `,
+      )
+      .all(searchPattern, searchPattern, searchPattern);
+
+    db.close();
 
     if (!memories || memories.length === 0) {
       console.log(chalk.yellow('No memories found matching your search.'));
       return;
     }
 
+    console.log(chalk.gray(`Found ${memories.length} memories matching "${searchTerm}":\n`));
+
     memories.forEach((memory, index) => {
-      console.log(chalk.green(`${index + 1}. ${memory.key || `result-${index}`}`));
-      console.log(`   Category: ${memory.type || 'general'}`);
-      console.log(`   Created: ${new Date(memory.timestamp || Date.now()).toLocaleString()}`);
-      console.log(`   Value: ${JSON.stringify(memory.value || memory, null, 2)}`);
+      console.log(chalk.green(`${index + 1}. ${memory.key}`));
+      console.log(`   Swarm: ${memory.swarm_name || memory.swarm_id}`);
+      console.log(`   Type: ${memory.type || 'knowledge'}`);
+      console.log(`   Created: ${new Date(memory.created_at).toLocaleString()}`);
+      
+      // Parse and display value with highlighting
+      let displayValue = memory.value;
+      try {
+        const parsed = JSON.parse(memory.value);
+        displayValue = JSON.stringify(parsed, null, 2);
+      } catch {
+        // Keep as string
+      }
+      
+      console.log(`   Value: ${displayValue}`);
       console.log('');
     });
   } catch (error) {

package/src/cli/simple-commands/init/templates/CLAUDE.md

@@ -458,14 +458,14 @@ If you need to do X operations, they should be in 1 message, not X messages
   mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
   mcp__claude-flow__agent_spawn { type: "researcher" }
   mcp__claude-flow__agent_spawn { type: "coder" }
-  mcp__claude-flow__agent_spawn { type: "analyst" }
+  mcp__claude-flow__agent_spawn { type: "code-analyzer" }
   mcp__claude-flow__agent_spawn { type: "tester" }
-  mcp__claude-flow__agent_spawn { type: "coordinator" }
+  mcp__claude-flow__agent_spawn { type: "task-orchestrator" }
 
   // Claude Code execution - ALL in parallel
   Task("You are researcher agent. MUST coordinate via hooks...")
   Task("You are coder agent. MUST coordinate via hooks...")
-  Task("You are analyst agent. MUST coordinate via hooks...")
+  Task("You are code-analyzer agent. MUST coordinate via hooks...")
   Task("You are tester agent. MUST coordinate via hooks...")
   TodoWrite { todos: [5-10 todos with all priorities and statuses] }
 
@@ -601,7 +601,7 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 - Tool: `mcp__claude-flow__agent_spawn`
 - Parameters: `{"type": "researcher", "name": "Literature Review"}`
 - Tool: `mcp__claude-flow__agent_spawn`
-- Parameters: `{"type": "analyst", "name": "Data Analysis"}`
+- Parameters: `{"type": "code-analyzer", "name": "Data Analysis"}`
 - Result: Different cognitive patterns for Claude Code to use
 
 **Step 3:** Coordinate research execution
@@ -634,7 +634,7 @@ Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
 **Step 2:** Define development perspectives
 
 - Tool: `mcp__claude-flow__agent_spawn`
-- Parameters: `{"type": "architect", "name": "System Design"}`
+- Parameters: `{"type": "system-architect", "name": "System Design"}`
 - Result: Architectural thinking pattern for Claude Code
 
 **Step 3:** Coordinate implementation
@@ -802,9 +802,9 @@ See `.claude/commands/` for detailed documentation on all features.
    - Medium tasks (4-6 components): 5-7 agents
    - Complex tasks (7+ components): 8-12 agents
 3. **Agent Type Distribution**: Balance agent types based on task:
-   - Always include 1 coordinator
+   - Always include 1 task-orchestrator
    - For code-heavy tasks: more coders
-   - For design tasks: more architects/analysts
+   - For design tasks: more system-architects/code-analyzers
    - For quality tasks: more testers/reviewers
 
 **Example Auto-Decision Logic:**
@@ -896,15 +896,15 @@ Message 1: [BatchTool]
   - mcp__claude-flow__swarm_init
   - mcp__claude-flow__agent_spawn (researcher)
   - mcp__claude-flow__agent_spawn (coder)
-  - mcp__claude-flow__agent_spawn (analyst)
+  - mcp__claude-flow__agent_spawn (code-analyzer)
   - mcp__claude-flow__agent_spawn (tester)
-  - mcp__claude-flow__agent_spawn (coordinator)
+  - mcp__claude-flow__agent_spawn (task-orchestrator)
 
 Message 2: [BatchTool - Claude Code execution]
   // Task agents with full coordination instructions
   - Task("You are researcher agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Research API patterns")
   - Task("You are coder agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Implement REST endpoints")
-  - Task("You are analyst agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Analyze performance")
+  - Task("You are code-analyzer agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Analyze performance")
   - Task("You are tester agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Write comprehensive tests")
 
   // TodoWrite with ALL todos batched
@@ -940,13 +940,13 @@ STEP 1: IMMEDIATE PARALLEL SPAWN (Single Message!)
 
   // Spawn agents based on maxAgents count and task requirements
   // If CLI specifies 3 agents, spawn 3. If no args, auto-decide optimal count (3-12)
-  - mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
+  - mcp__claude-flow__agent_spawn { type: "system-architect", name: "System Designer" }
   - mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
   - mcp__claude-flow__agent_spawn { type: "coder", name: "Frontend Dev" }
-  - mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
+  - mcp__claude-flow__agent_spawn { type: "code-analyzer", name: "DB Designer" }
   - mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
   - mcp__claude-flow__agent_spawn { type: "researcher", name: "Tech Lead" }
-  - mcp__claude-flow__agent_spawn { type: "coordinator", name: "PM" }
+  - mcp__claude-flow__agent_spawn { type: "task-orchestrator", name: "PM" }
   - TodoWrite { todos: [multiple todos at once] }
 
 STEP 2: PARALLEL TASK EXECUTION (Single Message!)
@@ -998,12 +998,12 @@ Dependencies: ↳ X deps | Actionable: ▶
 [BatchTool - Message 1]:
   // Initialize and spawn ALL agents at once
   mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8, strategy: "parallel" }
-  mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
+  mcp__claude-flow__agent_spawn { type: "system-architect", name: "System Designer" }
   mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
   mcp__claude-flow__agent_spawn { type: "coder", name: "Auth Expert" }
-  mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
+  mcp__claude-flow__agent_spawn { type: "code-analyzer", name: "DB Designer" }
   mcp__claude-flow__agent_spawn { type: "tester", name: "Test Engineer" }
-  mcp__claude-flow__agent_spawn { type: "coordinator", name: "Lead" }
+  mcp__claude-flow__agent_spawn { type: "task-orchestrator", name: "Lead" }
 
   // Update ALL todos at once - NEVER split todos!
   TodoWrite { todos: [
@@ -1109,12 +1109,12 @@ When showing swarm status, use this format:
 └── 🧠 Memory: 15 coordination points stored
 
 Agent Activity:
-├── 🟢 architect: Designing database schema...
+├── 🟢 system-architect: Designing database schema...
 ├── 🟢 coder-1: Implementing auth endpoints...
 ├── 🟢 coder-2: Building user CRUD operations...
-├── 🟢 analyst: Optimizing query performance...
+├── 🟢 code-analyzer: Optimizing query performance...
 ├── 🟡 tester: Waiting for auth completion...
-└── 🟢 coordinator: Monitoring progress...
+└── 🟢 task-orchestrator: Monitoring progress...
 ```
 
 ## 📝 CRITICAL: TODOWRITE AND TASK TOOL BATCHING

package/src/cli/simple-commands/process-ui-enhanced.js

@@ -1,4 +1,4 @@
-// process-ui-enhanced.js - Enhanced process management UI with multiple views - v2.0.0-alpha.81
+// process-ui-enhanced.js - Enhanced process management UI with multiple views - v2.0.0-alpha.83
 import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
 import { compat } from '../runtime-detector.js';
 import SwarmWebUIIntegration from './swarm-webui-integration.js';

package/src/cli/simple-commands/status.js

@@ -19,7 +19,7 @@ export async function statusCommand(subArgs, flags) {
 async function getSystemStatus(verbose = false) {
   const status = {
     timestamp: Date.now(),
-    version: '2.0.0-alpha.81',
+    version: '2.0.0-alpha.83',
     orchestrator: {
       running: false,
       uptime: 0,

package/src/cli/simple-commands/swarm.js

@@ -156,14 +156,17 @@ EXAMPLES:
   claude-flow swarm "Develop user registration feature" --mode distributed
   claude-flow swarm "Optimize React app performance" --strategy optimization
   claude-flow swarm "Create microservice" --executor  # Use built-in executor
+  claude-flow swarm "Build API" --claude  # Open Claude Code CLI
   claude-flow swarm "Build API endpoints" --output-format json  # Get JSON output
   claude-flow swarm "Research AI trends" --output-format json --output-file results.json
 
 DEFAULT BEHAVIOR:
-  Swarm now opens Claude Code by default with comprehensive MCP tool instructions
+  Swarm attempts to open Claude Code CLI with comprehensive MCP tool instructions
   including memory coordination, agent management, and task orchestration.
   
-  Use --executor flag to run with the built-in executor instead of Claude Code
+  If Claude CLI is not available:
+  • Use --claude flag to open Claude Code CLI
+  • Use --executor flag to run with the built-in executor
 
 STRATEGIES:
   auto           Automatically determine best approach (default)
@@ -210,6 +213,7 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
+  --claude                   Open Claude Code CLI
   --output-format <format>   Output format: json, text (default: text)
   --output-file <path>       Save output to file instead of stdout
   --no-interactive           Run in non-interactive mode (auto-enabled with --output-format json)
@@ -352,33 +356,7 @@ export async function swarmCommand(args, flags) {
     try {
       const { execSync, spawn } = await import('child_process');
 
-      // Check if claude command exists
-      let claudeAvailable = false;
-      try {
-        execSync('which claude', { stdio: 'ignore' });
-        claudeAvailable = true;
-      } catch {
-        console.log('⚠️  Claude Code CLI not found in PATH');
-        console.log('Install it with: npm install -g @anthropic-ai/claude-code');
-        console.log('\nWould spawn Claude Code with swarm objective:');
-        console.log(`📋 Objective: ${objective}`);
-        console.log(
-          '\nTo use the built-in executor instead: claude-flow swarm "objective" --executor',
-        );
-        return;
-      }
-
-      // Claude is available, use it to run swarm
-      console.log('🐝 Launching Claude Flow Swarm System...');
-      console.log(`📋 Objective: ${objective}`);
-      console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-      console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
-      console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
-      if (isAnalysisMode) {
-        console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
-      }
-      console.log();
-
+      // Get configuration values first
       const strategy = flags.strategy || 'auto';
       const mode = flags.mode || 'centralized';
       const maxAgents = flags['max-agents'] || 5;
@@ -391,6 +369,7 @@ export async function swarmCommand(args, flags) {
       const enableSparc =
         flags.sparc !== false && (strategy === 'development' || strategy === 'auto');
 
+      // Build the complete swarm prompt before checking for claude
       const swarmPrompt = `You are orchestrating a Claude Flow Swarm with advanced MCP tool coordination.
 
 🎯 OBJECTIVE: ${objective}
@@ -787,6 +766,109 @@ Start by spawning a coordinator agent and creating the initial task structure. U
 
 The swarm should be self-documenting - use memory_store to save all important information, decisions, and results throughout the execution.`;
 
+      // If --claude flag is used, force Claude Code even if CLI not available
+      if (flags && flags.claude) {
+        console.log('🐝 Launching Claude Flow Swarm System...');
+        console.log(`📋 Objective: ${objective}`);
+        console.log(`🎯 Strategy: ${strategy}`);
+        console.log(`🏗️  Mode: ${mode}`);
+        console.log(`🤖 Max Agents: ${maxAgents}\n`);
+        
+        console.log('🚀 Launching Claude Code with Swarm Coordination');
+        console.log('─'.repeat(60));
+        
+        // Pass the prompt directly as an argument to claude
+        const claudeArgs = [swarmPrompt];
+        
+        // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+          claudeArgs.push('--dangerously-skip-permissions');
+          console.log('🔓 Using --dangerously-skip-permissions by default for seamless swarm execution');
+        }
+        
+        // Spawn claude with the prompt as the first argument (exactly like hive-mind does)
+        const claudeProcess = spawn('claude', claudeArgs, {
+          stdio: 'inherit',
+          shell: false,
+        });
+        
+        console.log('\n✓ Claude Code launched with swarm coordination prompt!');
+        console.log('  The swarm coordinator will orchestrate all agent tasks');
+        console.log('  Use MCP tools for coordination and memory sharing');
+        
+        console.log('\n💡 Pro Tips:');
+        console.log('─'.repeat(30));
+        console.log('• Use TodoWrite to track parallel tasks');
+        console.log('• Store results with mcp__claude-flow__memory_usage');
+        console.log('• Monitor progress with mcp__claude-flow__swarm_monitor');
+        console.log('• Check task status with mcp__claude-flow__task_status');
+        
+        // Set up clean termination
+        const cleanup = () => {
+          console.log('\n🛑 Shutting down swarm gracefully...');
+          if (claudeProcess && !claudeProcess.killed) {
+            claudeProcess.kill('SIGTERM');
+          }
+          process.exit(0);
+        };
+        
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        
+        // Wait for claude to exit
+        claudeProcess.on('exit', (code) => {
+          if (code === 0) {
+            console.log('\n✓ Swarm execution completed successfully');
+          } else if (code !== null) {
+            console.log(`\n✗ Swarm execution exited with code ${code}`);
+          }
+          process.exit(code || 0);
+        });
+        
+        // Handle spawn errors (e.g., claude not found)
+        claudeProcess.on('error', (err) => {
+          if (err.code === 'ENOENT') {
+            console.error('\n❌ Claude Code CLI not found. Please install Claude Code:');
+            console.error('   https://claude.ai/download');
+          } else {
+            console.error('\n❌ Failed to launch Claude Code:', err.message);
+          }
+          process.exit(1);
+        });
+        
+        return;
+      }
+
+      // Check if claude command exists
+      let claudeAvailable = false;
+      try {
+        execSync('which claude', { stdio: 'ignore' });
+        claudeAvailable = true;
+      } catch {
+        console.log('⚠️  Claude Code CLI not found in PATH');
+        console.log('Install it with: npm install -g @anthropic-ai/claude-code');
+        console.log('Or use --claude flag to open Claude Code CLI');
+        console.log('\nWould spawn Claude Code with swarm objective:');
+        console.log(`📋 Objective: ${objective}`);
+        console.log('\nOptions:');
+        console.log('  • Use --executor flag for built-in executor: claude-flow swarm "objective" --executor');
+        console.log('  • Use --claude flag to open Claude Code CLI: claude-flow swarm "objective" --claude');
+        return;
+      }
+
+      // Claude is available, use it to run swarm
+      console.log('🐝 Launching Claude Flow Swarm System...');
+      console.log(`📋 Objective: ${objective}`);
+      console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+      console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+      console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+      if (isAnalysisMode) {
+        console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
+      }
+      console.log();
+
+      // Continue with the default swarm behavior if not using --claude flag
+
       // Pass the prompt directly as an argument to claude
       const claudeArgs = [swarmPrompt];
 
@@ -812,8 +894,9 @@ The swarm should be self-documenting - use memory_store to save all important in
         claudeArgs.push('--output-format', 'stream-json'); // JSON streaming
         claudeArgs.push('--verbose'); // Verbose output
         
-        console.log('🤖 Running in non-interactive mode with Claude');
+        console.log('🤖 Running in non-interactive mode with Claude CLI');
         console.log('📋 Command: claude [prompt] -p --output-format stream-json --verbose');
+        console.log('💡 Tip: Use --claude flag to open Claude Code CLI instead');
       }
 
       // Spawn claude with the prompt as the first argument
@@ -1400,6 +1483,7 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
+  --claude                   Open Claude Code CLI
   --output-format <format>   Output format: json, text (default: text)
   --output-file <path>       Save output to file instead of stdout
   --no-interactive           Run in non-interactive mode (auto-enabled with --output-format json)

package/src/constants/agent-types.ts

@@ -3,21 +3,18 @@
  * This file provides type-safe access to dynamically loaded agent definitions
  */
 
-import { getAvailableAgentTypes, isValidAgentType as validateAgentType } from '../agents/agent-loader.js';
+import { 
+  getAvailableAgentTypes, 
+  isValidAgentType as validateAgentType,
+  resolveLegacyAgentType as resolveLegacy,
+  LEGACY_AGENT_MAPPING as LEGACY_MAPPING
+} from '../agents/agent-loader.js';
 
 // Dynamic agent type - will be a string that matches available agents
 export type AgentType = string;
 
-// Legacy agent type mapping for backward compatibility
-export const LEGACY_AGENT_MAPPING = {
-  analyst: 'code-analyzer',
-  coordinator: 'task-orchestrator', 
-  optimizer: 'perf-analyzer',
-  documenter: 'api-docs',
-  monitor: 'performance-benchmarker',
-  specialist: 'system-architect',
-  architect: 'system-architect',
-} as const;
+// Re-export legacy mapping from agent-loader
+export const LEGACY_AGENT_MAPPING = LEGACY_MAPPING;
 
 /**
  * Get all valid agent types dynamically
@@ -36,10 +33,7 @@ export async function isValidAgentType(type: string): Promise<boolean> {
 /**
  * Resolve legacy agent types to current equivalents
  */
-export function resolveLegacyAgentType(legacyType: string): string {
-  const mapped = LEGACY_AGENT_MAPPING[legacyType as keyof typeof LEGACY_AGENT_MAPPING];
-  return mapped || legacyType;
-}
+export const resolveLegacyAgentType = resolveLegacy;
 
 /**
  * Create JSON Schema for agent type validation (async)