claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

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

@@ -11,10 +11,12 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
 import { args, cwd, exit, writeTextFile, readTextFile, mkdirAsync } from '../node-compat.js';
-import { isInteractive, isRawModeSupported, warnNonInteractive, checkNonInteractiveAuth } from '../utils/interactive-detector.js';
-import { safeInteractive, nonInteractiveProgress, nonInteractiveSelect } from '../utils/safe-interactive.js';
+import { isInteractive, isRawModeSupported, warnNonInteractive, checkNonInteractiveAuth, } from '../utils/interactive-detector.js';
+import { safeInteractive, nonInteractiveProgress, nonInteractiveSelect, } from '../utils/safe-interactive.js';
 // Import SQLite for persistence
 import Database from 'better-sqlite3';
+// Import help formatter
+import { HelpFormatter } from '../help-formatter.js';
 // Import MCP tool wrappers
 import { MCPToolWrapper } from './hive-mind/mcp-wrapper.js';
 import { HiveMindCore } from './hive-mind/core.js';
@@ -93,8 +95,6 @@ ${chalk.bold('OPTIONS:')}
   --spawn                Alias for --claude
   --auto-spawn           Automatically spawn Claude Code instances
   --execute              Execute Claude Code spawn commands immediately
-  --auto                 (Deprecated: auto-permissions enabled by default)
-  --no-auto-permissions  Disable automatic --dangerously-skip-permissions
 
 ${chalk.bold('For more information:')}
 ${chalk.blue('https://github.com/ruvnet/claude-flow/tree/main/docs/hive-mind')}
@@ -191,13 +191,13 @@ async function initHiveMind(flags) {
                 consensusAlgorithm: 'majority',
                 memorySize: 100,
                 autoScale: true,
-                encryption: false
+                encryption: false,
             },
             mcpTools: {
                 enabled: true,
                 parallel: true,
-                timeout: 60000
-            }
+                timeout: 60000,
+            },
         };
         await writeFile(path.join(hiveMindDir, 'config.json'), JSON.stringify(config, null, 2));
         spinner.succeed('Hive Mind system initialized successfully!');
@@ -234,9 +234,9 @@ async function (flags = {}) {
                 { name: '🤝 View consensus decisions', value: 'consensus' },
                 { name: '📈 Performance metrics', value: 'metrics' },
                 { name: '🔧 Configure hive mind', value: 'config' },
-                { name: '❌ Exit', value: 'exit' }
-            ]
-        }
+                { name: '❌ Exit', value: 'exit' },
+            ],
+        },
     ]);
     switch (action) {
         case 'spawn':
@@ -279,7 +279,7 @@ async function (flags = {}) {
         maxWorkers: parseInt(flags.maxWorkers || flags['max-workers'] || '8'),
         consensusAlgorithm: flags.consensus || 'majority',
         autoScale: flags.autoScale || flags['auto-scale'] || false,
-        encryption: flags.encryption || false
+        encryption: flags.encryption || false,
     };
     await spawnSwarm([objective], {
         ...flags,
@@ -289,7 +289,7 @@ async function (flags = {}) {
         consensusAlgorithm: config.consensusAlgorithm,
         autoScale: config.autoScale,
         encryption: config.encryption,
-        nonInteractive: true
+        nonInteractive: true,
     });
 });
 /**
@@ -301,13 +301,13 @@ async function spawnSwarmWizard() {
             type: 'input',
             name: 'objective',
             message: 'What is the swarm objective?',
-            validate: input => input.trim().length > 0 || 'Please enter an objective'
+            validate: (input) => input.trim().length > 0 || 'Please enter an objective',
         },
         {
             type: 'input',
             name: 'name',
             message: 'Swarm name (optional):',
-            default: answers => `swarm-${Date.now()}`
+            default: (answers) => `swarm-${Date.now()}`,
         },
         {
             type: 'list',
@@ -316,16 +316,16 @@ async function spawnSwarmWizard() {
             choices: [
                 { name: 'Strategic - High-level planning and coordination', value: 'strategic' },
                 { name: 'Tactical - Detailed task management', value: 'tactical' },
-                { name: 'Adaptive - Learns and adapts strategies', value: 'adaptive' }
+                { name: 'Adaptive - Learns and adapts strategies', value: 'adaptive' },
             ],
-            default: 'strategic'
+            default: 'strategic',
         },
         {
             type: 'number',
             name: 'maxWorkers',
             message: 'Maximum number of worker agents:',
             default: 8,
-            validate: input => input > 0 && input <= 20 || 'Please enter a number between 1 and 20'
+            validate: (input) => (input > 0 && input <= 20) || 'Please enter a number between 1 and 20',
         },
         {
             type: 'checkbox',
@@ -339,8 +339,8 @@ async function spawnSwarmWizard() {
                 { name: 'Architect', value: 'architect' },
                 { name: 'Reviewer', value: 'reviewer' },
                 { name: 'Optimizer', value: 'optimizer' },
-                { name: 'Documenter', value: 'documenter' }
-            ]
+                { name: 'Documenter', value: 'documenter' },
+            ],
         },
         {
             type: 'list',
@@ -349,22 +349,22 @@ async function spawnSwarmWizard() {
             choices: [
                 { name: 'Majority - Simple majority voting', value: 'majority' },
                 { name: 'Weighted - Expertise-weighted voting', value: 'weighted' },
-                { name: 'Byzantine - Fault-tolerant consensus', value: 'byzantine' }
+                { name: 'Byzantine - Fault-tolerant consensus', value: 'byzantine' },
             ],
-            default: 'majority'
+            default: 'majority',
         },
         {
             type: 'confirm',
             name: 'autoScale',
             message: 'Enable auto-scaling?',
-            default: true
+            default: true,
         },
         {
             type: 'confirm',
             name: 'monitor',
             message: 'Launch monitoring dashboard?',
-            default: true
-        }
+            default: true,
+        },
     ]);
     // Spawn the swarm with collected parameters
     await spawnSwarm([answers.objective], {
@@ -374,7 +374,7 @@ async function spawnSwarmWizard() {
         workerTypes: answers.workerTypes.join(','),
         consensus: answers.consensusAlgorithm,
         autoScale: answers.autoScale,
-        monitor: answers.monitor
+        monitor: answers.monitor,
     });
 }
 /**
@@ -400,7 +400,7 @@ async function spawnSwarm(args, flags) {
                 maxWorkers: flags.maxWorkers || 8,
                 consensusAlgorithm: flags.consensus || 'majority',
                 autoScale: flags.autoScale !== false,
-                encryption: flags.encryption || false
+                encryption: flags.encryption || false,
             });
         }
         catch (error) {
@@ -538,28 +538,28 @@ async function spawnSwarm(args, flags) {
             consensusAlgorithm: hiveMind.config.consensusAlgorithm,
             autoScale: hiveMind.config.autoScale,
             encryption: hiveMind.config.encryption,
-            workerTypes: flags.workerTypes
+            workerTypes: flags.workerTypes,
         });
         spinner.text = 'Session tracking established...';
         sessionManager.close();
         // Initialize auto-save middleware
         const autoSave = createAutoSaveMiddleware(sessionId, {
             saveInterval: 30000, // Save every 30 seconds
-            autoStart: true
+            autoStart: true,
         });
         // Track initial swarm creation
         autoSave.trackChange('swarm_created', {
             swarmId,
             swarmName: hiveMind.config.name,
             objective,
-            workerCount: hiveMind.config.maxWorkers
+            workerCount: hiveMind.config.maxWorkers,
         });
         spinner.text = 'Initializing Queen coordinator...';
         // Initialize Queen
         const queen = new QueenCoordinator({
             swarmId,
             type: hiveMind.config.queenType,
-            objective
+            objective,
         });
         // Spawn Queen agent
         const queenAgent = {
@@ -569,7 +569,7 @@ async function spawnSwarm(args, flags) {
             type: 'coordinator',
             role: 'queen',
             status: 'active',
-            capabilities: JSON.stringify(['coordination', 'planning', 'decision-making'])
+            capabilities: JSON.stringify(['coordination', 'planning', 'decision-making']),
         };
         db.prepare(`
       INSERT INTO agents (id, swarm_id, name, type, role, status, capabilities)
@@ -592,7 +592,7 @@ async function spawnSwarm(args, flags) {
                 type: workerType,
                 role: 'worker',
                 status: 'idle',
-                capabilities: JSON.stringify(getAgentCapabilities(workerType))
+                capabilities: JSON.stringify(getAgentCapabilities(workerType)),
             };
             workers.push(worker);
             db.prepare(`
@@ -602,14 +602,14 @@ async function spawnSwarm(args, flags) {
             // Track agent spawning for auto-save
             autoSave.trackAgentActivity(workerId, 'spawned', {
                 type: workerType,
-                name: worker.name
+                name: worker.name,
             });
         }
         spinner.text = 'Initializing collective memory...';
         // Initialize collective memory
         const memory = new CollectiveMemory({
             swarmId,
-            maxSize: flags.memorySize || 100
+            maxSize: flags.memorySize || 100,
         });
         // Store initial context
         memory.store('objective', objective, 'context');
@@ -620,7 +620,7 @@ async function spawnSwarm(args, flags) {
         // Initialize communication system
         const communication = new SwarmCommunication({
             swarmId,
-            encryption: hiveMind.config.encryption
+            encryption: hiveMind.config.encryption,
         });
         db.close();
         spinner.succeed('Hive Mind swarm spawned successfully!');
@@ -653,7 +653,9 @@ async function spawnSwarm(args, flags) {
             await spawnClaudeCodeInstances(swarmId, hiveMind.config.name, objective, workers, flags);
         }
         else {
-            console.log('\n' + chalk.blue('💡 Pro Tip:') + ' Add --claude to spawn coordinated Claude Code instances');
+            console.log('\n' +
+                chalk.blue('💡 Pro Tip:') +
+                ' Add --claude to spawn coordinated Claude Code instances');
             console.log(chalk.gray('   claude-flow hive-mind spawn "objective" --claude'));
         }
     }
@@ -686,7 +688,7 @@ function getAgentCapabilities(type) {
         architect: ['system-design', 'architecture', 'planning', 'documentation'],
         reviewer: ['code-review', 'quality-check', 'feedback', 'improvement'],
         optimizer: ['performance-tuning', 'optimization', 'profiling', 'enhancement'],
-        documenter: ['documentation', 'explanation', 'tutorial-creation', 'knowledge-base']
+        documenter: ['documentation', 'explanation', 'tutorial-creation', 'knowledge-base'],
     };
     return capabilities[type] || ['general'];
 }
@@ -703,11 +705,13 @@ async function showStatus(flags) {
         }
         const db = new Database(dbPath);
         // Get active swarms
-        const swarms = db.prepare(`
+        const swarms = db
+            .prepare(`
       SELECT * FROM swarms 
       WHERE status = 'active' 
       ORDER BY created_at DESC
-    `).all();
+    `)
+            .all();
         if (swarms.length === 0) {
             console.log(chalk.gray('No active swarms found'));
             db.close();
@@ -723,25 +727,27 @@ async function showStatus(flags) {
             console.log(chalk.cyan('Status:'), chalk.green(swarm.status));
             console.log(chalk.cyan('Created:'), new Date(swarm.created_at).toLocaleString());
             // Get agents
-            const agents = db.prepare(`
+            const agents = db
+                .prepare(`
         SELECT * FROM agents 
         WHERE swarm_id = ?
-      `).all(swarm.id);
+      `)
+                .all(swarm.id);
             console.log('\n' + chalk.bold('Agents:'));
             // Group by role
-            const queen = agents.find(a => a.role === 'queen');
-            const workers = agents.filter(a => a.role === 'worker');
+            const queen = agents.find((a) => a.role === 'queen');
+            const workers = agents.filter((a) => a.role === 'worker');
             if (queen) {
                 console.log('  ' + chalk.magenta('👑 Queen:'), queen.name, chalk.gray(`(${queen.status})`));
             }
             console.log('  ' + chalk.blue('🐝 Workers:'));
-            workers.forEach(worker => {
-                const statusColor = worker.status === 'active' ? 'green' :
-                    worker.status === 'busy' ? 'yellow' : 'gray';
+            workers.forEach((worker) => {
+                const statusColor = worker.status === 'active' ? 'green' : worker.status === 'busy' ? 'yellow' : 'gray';
                 console.log(`    - ${worker.name} (${worker.type}) ${chalk[statusColor](worker.status)}`);
             });
             // Get task statistics
-            const taskStats = db.prepare(`
+            const taskStats = db
+                .prepare(`
         SELECT 
           COUNT(*) as total,
           SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
@@ -749,24 +755,29 @@ async function showStatus(flags) {
           SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending
         FROM tasks
         WHERE swarm_id = ?
-      `).get(swarm.id);
+      `)
+                .get(swarm.id);
             console.log('\n' + chalk.bold('Tasks:'));
             console.log(`  Total: ${taskStats.total}`);
             console.log(`  Completed: ${chalk.green(taskStats.completed)}`);
             console.log(`  In Progress: ${chalk.yellow(taskStats.in_progress)}`);
             console.log(`  Pending: ${chalk.gray(taskStats.pending)}`);
             // Get memory stats
-            const memoryCount = db.prepare(`
+            const memoryCount = db
+                .prepare(`
         SELECT COUNT(*) as count FROM collective_memory
         WHERE swarm_id = ?
-      `).get(swarm.id);
+      `)
+                .get(swarm.id);
             console.log('\n' + chalk.bold('Collective Memory:'));
             console.log(`  Entries: ${memoryCount.count}`);
             // Get consensus stats
-            const consensusCount = db.prepare(`
+            const consensusCount = db
+                .prepare(`
         SELECT COUNT(*) as count FROM consensus_decisions
         WHERE swarm_id = ?
-      `).get(swarm.id);
+      `)
+                .get(swarm.id);
             console.log('\n' + chalk.bold('Consensus Decisions:'));
             console.log(`  Total: ${consensusCount.count}`);
         }
@@ -785,20 +796,22 @@ async function showConsensus(flags) {
     try {
         const dbPath = path.join(cwd(), '.hive-mind', 'hive.db');
         const db = new Database(dbPath);
-        const decisions = db.prepare(`
+        const decisions = db
+            .prepare(`
       SELECT cd.*, s.name as swarm_name
       FROM consensus_decisions cd
       JOIN swarms s ON cd.swarm_id = s.id
       ORDER BY cd.created_at DESC
       LIMIT 20
-    `).all();
+    `)
+            .all();
         if (decisions.length === 0) {
             console.log(chalk.gray('No consensus decisions found'));
             db.close();
             return;
         }
         console.log(chalk.bold('\n🤝 Recent Consensus Decisions\n'));
-        decisions.forEach(decision => {
+        decisions.forEach((decision) => {
             console.log(chalk.yellow('─'.repeat(50)));
             console.log(chalk.cyan('Swarm:'), decision.swarm_name);
             console.log(chalk.cyan('Topic:'), decision.topic);
@@ -820,7 +833,11 @@ async function showConsensus(flags) {
                         votes.details.forEach((detail, index) => {
                             if (typeof detail === 'object') {
                                 // Extract available fields
-                                const agent = detail.agentId || detail.agent || detail.id || detail.name || `agent-${index + 1}`;
+                                const agent = detail.agentId ||
+                                    detail.agent ||
+                                    detail.id ||
+                                    detail.name ||
+                                    `agent-${index + 1}`;
                                 const vote = detail.vote || detail.choice || detail.decision || 'unknown';
                                 const reason = detail.reason || detail.justification || detail.rationale;
                                 // Build display string
@@ -861,23 +878,27 @@ async function showMetrics(flags) {
         const dbPath = path.join(cwd(), '.hive-mind', 'hive.db');
         const db = new Database(dbPath);
         // Get overall metrics
-        const overallStats = db.prepare(`
+        const overallStats = db
+            .prepare(`
       SELECT 
         (SELECT COUNT(*) FROM swarms) as total_swarms,
         (SELECT COUNT(*) FROM agents) as total_agents,
         (SELECT COUNT(*) FROM tasks) as total_tasks,
         (SELECT COUNT(*) FROM tasks WHERE status = 'completed') as completed_tasks
-    `).get();
+    `)
+            .get();
         console.log(chalk.bold('\n📊 Hive Mind Performance Metrics\n'));
         // Get task status breakdown
-        const taskBreakdown = db.prepare(`
+        const taskBreakdown = db
+            .prepare(`
       SELECT 
         status,
         COUNT(*) as count
       FROM tasks
       GROUP BY status
       ORDER BY count DESC
-    `).all();
+    `)
+            .all();
         console.log(chalk.cyan('Overall Statistics:'));
         console.log(`  Total Swarms: ${overallStats.total_swarms}`);
         console.log(`  Total Agents: ${overallStats.total_agents}`);
@@ -888,13 +909,17 @@ async function showMetrics(flags) {
             : 'N/A'}`);
         if (taskBreakdown.length > 0) {
             console.log('\n' + chalk.cyan('Task Status Breakdown:'));
-            taskBreakdown.forEach(status => {
+            taskBreakdown.forEach((status) => {
                 const percentage = overallStats.total_tasks > 0
                     ? ((status.count / overallStats.total_tasks) * 100).toFixed(1)
                     : '0';
-                const statusColor = status.status === 'completed' ? 'green' :
-                    status.status === 'in_progress' ? 'yellow' :
-                        status.status === 'failed' ? 'red' : 'gray';
+                const statusColor = status.status === 'completed'
+                    ? 'green'
+                    : status.status === 'in_progress'
+                        ? 'yellow'
+                        : status.status === 'failed'
+                            ? 'red'
+                            : 'gray';
                 console.log(`  ${chalk[statusColor](status.status.charAt(0).toUpperCase() + status.status.slice(1))}: ${status.count} (${percentage}%)`);
             });
         }
@@ -902,12 +927,15 @@ async function showMetrics(flags) {
         let agentPerf = [];
         try {
             // Check if completed_at exists
-            const hasCompletedAt = db.prepare(`
+            const hasCompletedAt = db
+                .prepare(`
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `).get();
+      `)
+                .get();
             if (hasCompletedAt && hasCompletedAt.count > 0) {
-                agentPerf = db.prepare(`
+                agentPerf = db
+                    .prepare(`
           SELECT 
             a.name,
             a.type,
@@ -922,11 +950,13 @@ async function showMetrics(flags) {
           HAVING tasks_assigned > 0
           ORDER BY tasks_completed DESC
           LIMIT 10
-        `).all();
+        `)
+                    .all();
             }
             else {
                 // Simpler query without completed_at
-                agentPerf = db.prepare(`
+                agentPerf = db
+                    .prepare(`
           SELECT 
             a.name,
             a.type,
@@ -939,7 +969,8 @@ async function showMetrics(flags) {
           HAVING tasks_assigned > 0
           ORDER BY tasks_completed DESC
           LIMIT 10
-        `).all();
+        `)
+                    .all();
             }
         }
         catch (error) {
@@ -959,7 +990,8 @@ async function showMetrics(flags) {
             });
         }
         // Get swarm performance
-        const swarmPerf = db.prepare(`
+        const swarmPerf = db
+            .prepare(`
       SELECT 
         s.name,
         s.objective,
@@ -972,10 +1004,11 @@ async function showMetrics(flags) {
       WHERE s.status = 'active'
       ORDER BY s.created_at DESC
       LIMIT 5
-    `).all();
+    `)
+            .all();
         if (swarmPerf.length > 0) {
             console.log('\n' + chalk.cyan('Active Swarm Performance:'));
-            swarmPerf.forEach(swarm => {
+            swarmPerf.forEach((swarm) => {
                 const successRate = swarm.task_count > 0
                     ? ((swarm.completed_count / swarm.task_count) * 100).toFixed(1)
                     : '0';
@@ -989,19 +1022,23 @@ async function showMetrics(flags) {
         let avgTaskTime = { avg_minutes: null };
         try {
             // Check if completed_at exists
-            const hasCompletedAt = db.prepare(`
+            const hasCompletedAt = db
+                .prepare(`
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `).get();
+      `)
+                .get();
             if (hasCompletedAt && hasCompletedAt.count > 0) {
-                avgTaskTime = db.prepare(`
+                avgTaskTime = db
+                    .prepare(`
           SELECT 
             AVG(CASE WHEN completed_at IS NOT NULL 
               THEN (julianday(completed_at) - julianday(created_at)) * 24 * 60 
               ELSE NULL END) as avg_minutes
           FROM tasks
           WHERE status = 'completed'
-        `).get();
+        `)
+                    .get();
             }
         }
         catch (error) {
@@ -1011,12 +1048,15 @@ async function showMetrics(flags) {
         let agentTypePerf = [];
         try {
             // Check if completed_at exists
-            const hasCompletedAt = db.prepare(`
+            const hasCompletedAt = db
+                .prepare(`
         SELECT COUNT(*) as count FROM pragma_table_info('tasks') 
         WHERE name = 'completed_at'
-      `).get();
+      `)
+                .get();
             if (hasCompletedAt && hasCompletedAt.count > 0) {
-                agentTypePerf = db.prepare(`
+                agentTypePerf = db
+                    .prepare(`
           SELECT 
             a.type,
             COUNT(t.id) as total_tasks,
@@ -1029,11 +1069,13 @@ async function showMetrics(flags) {
           GROUP BY a.type
           HAVING total_tasks > 0
           ORDER BY completed_tasks DESC
-        `).all();
+        `)
+                    .all();
             }
             else {
                 // Simpler query without completed_at
-                agentTypePerf = db.prepare(`
+                agentTypePerf = db
+                    .prepare(`
           SELECT 
             a.type,
             COUNT(t.id) as total_tasks,
@@ -1044,7 +1086,8 @@ async function showMetrics(flags) {
           GROUP BY a.type
           HAVING total_tasks > 0
           ORDER BY completed_tasks DESC
-        `).all();
+        `)
+                    .all();
             }
         }
         catch (error) {
@@ -1055,7 +1098,7 @@ async function showMetrics(flags) {
             console.log(`  Average Task Completion Time: ${avgTaskTime.avg_minutes.toFixed(1)} minutes`);
             if (agentTypePerf.length > 0) {
                 console.log('\n' + chalk.cyan('Agent Type Performance:'));
-                agentTypePerf.forEach(type => {
+                agentTypePerf.forEach((type) => {
                     const successRate = type.total_tasks > 0
                         ? ((type.completed_tasks / type.total_tasks) * 100).toFixed(1)
                         : '0';
@@ -1091,9 +1134,9 @@ async function manageMemoryWizard() {
                 { name: '📊 Memory statistics', value: 'stats' },
                 { name: '🗑️ Clean old memories', value: 'clean' },
                 { name: '📤 Export memory backup', value: 'export' },
-                { name: '⬅️ Back to main menu', value: 'back' }
-            ]
-        }
+                { name: '⬅️ Back to main menu', value: 'back' },
+            ],
+        },
     ]);
     switch (action) {
         case 'list':
@@ -1124,8 +1167,8 @@ async function manageMemoryWizard() {
             type: 'confirm',
             name: 'continue',
             message: 'Would you like to perform another memory operation?',
-            default: true
-        }
+            default: true,
+        },
     ]);
     if (continueAction) {
         await manageMemoryWizard();
@@ -1144,8 +1187,12 @@ async function configureWizard() {
 export async function hiveMindCommand(args, flags) {
     const subcommand = args[0];
     const subArgs = args.slice(1);
-    // If no subcommand, show help
-    if (!subcommand) {
+    // Handle help flags
+    if (!subcommand ||
+        subcommand === '--help' ||
+        subcommand === '-h' ||
+        subcommand === 'help' ||
+        flags.help) {
         showHiveMindHelp();
         return;
     }
@@ -1253,8 +1300,8 @@ async function searchMemories() {
                 type: 'input',
                 name: 'searchTerm',
                 message: 'Enter search term:',
-                validate: input => input.length > 0
-            }
+                validate: (input) => input.length > 0,
+            },
         ]);
         console.log(chalk.blue(`\n🔍 Searching for: "${searchTerm}"\n`));
         const mcpWrapper = await getMcpWrapper();
@@ -1296,7 +1343,7 @@ async function storeMemoryWizard() {
                 type: 'input',
                 name: 'key',
                 message: 'Memory key (identifier):',
-                validate: input => input.length > 0
+                validate: (input) => input.length > 0,
             },
             {
                 type: 'list',
@@ -1310,14 +1357,14 @@ async function storeMemoryWizard() {
                     'coordination',
                     'performance',
                     'configuration',
-                    'general'
-                ]
+                    'general',
+                ],
             },
             {
                 type: 'editor',
                 name: 'value',
-                message: 'Memory content (JSON or text):'
-            }
+                message: 'Memory content (JSON or text):',
+            },
         ]);
         const mcpWrapper = await getMcpWrapper();
         let memoryValue;
@@ -1368,9 +1415,9 @@ async function showMemoryStats() {
             categories: {},
             oldestDate: null,
             newestDate: null,
-            totalSize: 0
+            totalSize: 0,
         };
-        memories.forEach(memory => {
+        memories.forEach((memory) => {
             // Count by category
             const category = memory.category || memory.type || 'general';
             stats.categories[category] = (stats.categories[category] || 0) + 1;
@@ -1408,16 +1455,16 @@ async function cleanMemories() {
                 name: 'days',
                 message: 'Remove memories older than how many days?',
                 default: 30,
-                validate: input => input > 0
-            }
+                validate: (input) => input > 0,
+            },
         ]);
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
                 name: 'confirm',
                 message: `Are you sure you want to delete memories older than ${days} days?`,
-                default: false
-            }
+                default: false,
+            },
         ]);
         if (!confirm) {
             console.log(chalk.yellow('Operation cancelled.'));
@@ -1440,7 +1487,7 @@ async function cleanMemories() {
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - days);
         // Filter memories older than cutoff date
-        const oldMemories = memories.filter(memory => {
+        const oldMemories = memories.filter((memory) => {
             const memoryDate = new Date(memory.timestamp || 0);
             return memoryDate < cutoffDate;
         });
@@ -1466,8 +1513,8 @@ async function exportMemoryBackup() {
                 type: 'input',
                 name: 'filename',
                 message: 'Export filename:',
-                default: `hive-mind-memory-backup-${new Date().toISOString().split('T')[0]}.json`
-            }
+                default: `hive-mind-memory-backup-${new Date().toISOString().split('T')[0]}.json`,
+            },
         ]);
         const mcpWrapper = await getMcpWrapper();
         // Get all memories using search
@@ -1488,7 +1535,7 @@ async function exportMemoryBackup() {
             version: '1.0',
             totalMemories: memories.length,
             namespace: 'hive-mind',
-            memories: memories
+            memories: memories,
         };
         const fs = await import('fs');
         fs.writeFileSync(filename, JSON.stringify(backup, null, 2));
@@ -1523,7 +1570,10 @@ async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers,
         console.log(chalk.cyan('MCP Tools:'), 'Full Claude-Flow integration enabled');
         try {
             // ALWAYS save the prompt file first (fix for issue #330)
-            const promptFile = `hive-mind-prompt-${swarmId}.txt`;
+            // Ensure sessions directory exists
+            const sessionsDir = path.join('.hive-mind', 'sessions');
+            await mkdirAsync(sessionsDir, { recursive: true });
+            const promptFile = path.join(sessionsDir, `hive-mind-prompt-${swarmId}.txt`);
             await writeFile(promptFile, hiveMindPrompt, 'utf8');
             console.log(chalk.green(`\n✓ Hive Mind prompt saved to: ${promptFile}`));
             // Check if claude command exists
@@ -1540,18 +1590,18 @@ async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers,
             }
             if (claudeAvailable && !flags.dryRun) {
                 // Pass the prompt directly as an argument to claude
-                // Using non-interactive mode to prevent hanging
-                const claudeArgs = [hiveMindPrompt, '--no-interactive'];
+                // Remove --print to allow interactive session
+                const claudeArgs = [hiveMindPrompt];
                 // Add auto-permission flag by default for hive-mind mode (unless explicitly disabled)
                 if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
                     claudeArgs.push('--dangerously-skip-permissions');
                     console.log(chalk.yellow('🔓 Using --dangerously-skip-permissions by default for seamless hive-mind execution'));
                 }
                 // Spawn claude with the prompt as the first argument
-                // Use 'pipe' instead of 'inherit' to prevent terminal conflicts
+                // Use 'inherit' to allow interactive session
                 const claudeProcess = childSpawn('claude', claudeArgs, {
-                    stdio: 'pipe',
-                    shell: false
+                    stdio: 'inherit',
+                    shell: false,
                 });
                 // Handle stdout
                 if (claudeProcess.stdout) {
@@ -1643,7 +1693,7 @@ HIVE MIND CONFIGURATION:
 ⏰ Initialized: ${currentTime}
 
 WORKER DISTRIBUTION:
-${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
+${workerTypes.map((type) => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
 
 🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
 
@@ -1683,7 +1733,7 @@ As the Queen coordinator, you must:
 
 1. **INITIALIZE THE HIVE** (Single BatchTool Message):
    [BatchTool]:
-   ${workerTypes.map(type => `   mcp__claude-flow__agent_spawn { "type": "${type}", "count": ${workerGroups[type].length} }`).join('\n')}
+   ${workerTypes.map((type) => `   mcp__claude-flow__agent_spawn { "type": "${type}", "count": ${workerGroups[type].length} }`).join('\n')}
    mcp__claude-flow__memory_store { "key": "hive/objective", "value": "${objective}" }
    mcp__claude-flow__memory_store { "key": "hive/queen", "value": "${queenType}" }
    mcp__claude-flow__swarm_think { "topic": "initial_strategy" }
@@ -1696,21 +1746,27 @@ As the Queen coordinator, you must:
    - Coordinate strategy with swarm_think
 
 3. **QUEEN LEADERSHIP PATTERNS**:
-   ${queenType === 'strategic' ? `
+   ${queenType === 'strategic'
+        ? `
    - Focus on high-level planning and coordination
    - Delegate implementation details to workers
    - Monitor overall progress and adjust strategy
-   - Make executive decisions when consensus fails` : ''}
-   ${queenType === 'tactical' ? `
+   - Make executive decisions when consensus fails`
+        : ''}
+   ${queenType === 'tactical'
+        ? `
    - Manage detailed task breakdowns and assignments
    - Closely monitor worker progress and efficiency
    - Optimize resource allocation and load balancing
-   - Intervene directly when workers need guidance` : ''}
-   ${queenType === 'adaptive' ? `
+   - Intervene directly when workers need guidance`
+        : ''}
+   ${queenType === 'adaptive'
+        ? `
    - Learn from swarm performance and adapt strategies
    - Experiment with different coordination patterns
    - Use neural training to improve over time
-   - Balance between strategic and tactical approaches` : ''}
+   - Balance between strategic and tactical approaches`
+        : ''}
 
 4. **WORKER COORDINATION**:
    - Spawn workers based on task requirements
@@ -1792,19 +1848,19 @@ function generateCoordinationInstructions(swarmId, swarmName, objective, workers
             'mcp__ruv-swarm__neural_train',
             'mcp__ruv-swarm__consensus_vote',
             'mcp__ruv-swarm__agent_spawn',
-            'mcp__ruv-swarm__swarm_status'
+            'mcp__ruv-swarm__swarm_status',
         ],
         coordinationProtocol: {
             memoryNamespace: `hive-mind-${swarmId}`,
             consensusThreshold: 0.7,
             taskUpdateInterval: 30000,
-            healthCheckInterval: 60000
+            healthCheckInterval: 60000,
         },
-        workerCapabilities: workers.map(w => ({
+        workerCapabilities: workers.map((w) => ({
             id: w.id,
             type: w.type,
-            capabilities: JSON.parse(w.capabilities)
-        }))
+            capabilities: JSON.parse(w.capabilities),
+        })),
     };
 }
 /**
@@ -1868,7 +1924,7 @@ Remember: You are part of a COLLECTIVE INTELLIGENCE. Your individual success dep
         command,
         context,
         workerType,
-        count: typeWorkers.length
+        count: typeWorkers.length,
     };
 }
 /**
@@ -1905,13 +1961,14 @@ function getWorkerTypeInstructions(workerType) {
 - Define technical standards and patterns
 - Create implementation guidelines
 - Review and approve design decisions
-- Ensure scalability and maintainability`
+- Ensure scalability and maintainability`,
     };
-    return instructions[workerType] || `- Execute tasks according to ${workerType} best practices
+    return (instructions[workerType] ||
+        `- Execute tasks according to ${workerType} best practices
 - Collaborate effectively with team members
 - Document work and share insights
 - Maintain quality standards
-- Contribute to collective objectives`;
+- Contribute to collective objectives`);
 }
 /**
  * Show all hive mind sessions
@@ -1927,10 +1984,8 @@ async function showSessions(flags) {
         }
         console.log(chalk.bold('\n🗂️  Hive Mind Sessions\n'));
         sessions.forEach((session, index) => {
-            const statusColor = session.status === 'active' ? 'green' :
-                session.status === 'paused' ? 'yellow' : 'gray';
-            const statusIcon = session.status === 'active' ? '🟢' :
-                session.status === 'paused' ? '🟡' : '⚫';
+            const statusColor = session.status === 'active' ? 'green' : session.status === 'paused' ? 'yellow' : 'gray';
+            const statusIcon = session.status === 'active' ? '🟢' : session.status === 'paused' ? '🟡' : '⚫';
             console.log(chalk.yellow('═'.repeat(60)));
             console.log(`${statusIcon} ${chalk.bold(session.swarm_name)}`);
             console.log(chalk.cyan('Session ID:'), session.id);
@@ -2009,7 +2064,7 @@ async function resumeSession(args, flags) {
         // Show recent activity
         if (resumedSession.recentLogs && resumedSession.recentLogs.length > 0) {
             console.log('\n' + chalk.bold('📜 Recent Activity:'));
-            resumedSession.recentLogs.slice(0, 5).forEach(log => {
+            resumedSession.recentLogs.slice(0, 5).forEach((log) => {
                 const timestamp = new Date(log.timestamp).toLocaleTimeString();
                 console.log(`  [${timestamp}] ${log.message}`);
             });
@@ -2029,7 +2084,9 @@ async function resumeSession(args, flags) {
             await launchClaudeWithContext(restoredPrompt, flags);
         }
         else {
-            console.log('\n' + chalk.blue('💡 Pro Tip:') + ' Add --claude to spawn Claude Code with restored context');
+            console.log('\n' +
+                chalk.blue('💡 Pro Tip:') +
+                ' Add --claude to spawn Claude Code with restored context');
             console.log(chalk.gray('   claude-flow hive-mind resume ' + sessionId + ' --claude'));
         }
     }
@@ -2086,8 +2143,8 @@ async function stopSession(args, flags) {
  * Generate prompt for restored session
  */
 function generateRestoredSessionPrompt(session) {
-    const activeAgents = session.agents.filter(a => a.status === 'active' || a.status === 'busy');
-    const pendingTasks = session.tasks.filter(t => t.status === 'pending' || t.status === 'in_progress');
+    const activeAgents = session.agents.filter((a) => a.status === 'active' || a.status === 'busy');
+    const pendingTasks = session.tasks.filter((t) => t.status === 'pending' || t.status === 'in_progress');
     return `🔄 RESUMING HIVE MIND SESSION
 ═══════════════════════════════════
 
@@ -2108,17 +2165,23 @@ CURRENT STATUS:
 • Pending Tasks: ${pendingTasks.length}
 
 ACTIVE AGENTS:
-${activeAgents.map(agent => `• ${agent.name} (${agent.type}) - ${agent.status}`).join('\n')}
+${activeAgents.map((agent) => `• ${agent.name} (${agent.type}) - ${agent.status}`).join('\n')}
 
 PENDING TASKS:
-${pendingTasks.slice(0, 10).map(task => `• [${task.priority}] ${task.description}`).join('\n')}
+${pendingTasks
+        .slice(0, 10)
+        .map((task) => `• [${task.priority}] ${task.description}`)
+        .join('\n')}
 ${pendingTasks.length > 10 ? `... and ${pendingTasks.length - 10} more tasks` : ''}
 
 CHECKPOINT DATA:
 ${session.checkpoint_data ? JSON.stringify(session.checkpoint_data, null, 2) : 'No checkpoint data available'}
 
 RECENT ACTIVITY:
-${session.recentLogs.slice(0, 10).map(log => `[${new Date(log.timestamp).toLocaleTimeString()}] ${log.message}`).join('\n')}
+${session.recentLogs
+        .slice(0, 10)
+        .map((log) => `[${new Date(log.timestamp).toLocaleTimeString()}] ${log.message}`)
+        .join('\n')}
 
 🎯 RESUMPTION PROTOCOL:
 
@@ -2161,14 +2224,14 @@ async function launchClaudeWithContext(prompt, flags) {
             return;
         }
         if (claudeAvailable && !flags.dryRun) {
-            const claudeArgs = [prompt, '--no-interactive'];
+            const claudeArgs = [prompt, '--print'];
             if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
                 claudeArgs.push('--dangerously-skip-permissions');
             }
             // Use 'pipe' instead of 'inherit' to prevent terminal conflicts
             const claudeProcess = childSpawn('claude', claudeArgs, {
                 stdio: 'pipe',
-                shell: false
+                shell: false,
             });
             // Handle stdout
             if (claudeProcess.stdout) {