@claude-flow/cli 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/commands/hive-mind.ts

@@ -125,13 +125,13 @@ const initCommand: Command = {
       output.writeln();
       output.printBox(
         [
-          `Hive ID: ${result.hiveId}`,
-          `Queen ID: ${result.queenId}`,
-          `Topology: ${result.topology}`,
-          `Consensus: ${result.consensus}`,
+          `Hive ID: ${result.hiveId ?? 'default'}`,
+          `Queen ID: ${result.queenId ?? 'N/A'}`,
+          `Topology: ${result.topology ?? config.topology}`,
+          `Consensus: ${result.consensus ?? config.consensus}`,
           `Max Agents: ${config.maxAgents}`,
           `Memory: ${config.memoryBackend}`,
-          `Status: ${output.success(result.status)}`
+          `Status: ${output.success(result.status ?? 'initialized')}`
         ].join('\n'),
         'Hive Mind Configuration'
       );
@@ -276,37 +276,42 @@ const statusCommand: Command = {
 
     try {
       const result = await callMCPTool<{
-        hiveId: string;
-        status: 'active' | 'idle' | 'degraded' | 'offline';
-        topology: string;
-        consensus: string;
-        queen: {
-          id: string;
-          status: string;
-          load: number;
-          tasksQueued: number;
+        hiveId?: string;
+        id?: string;
+        initialized?: boolean;
+        status?: 'active' | 'idle' | 'degraded' | 'offline' | 'running' | 'stopped';
+        topology?: string;
+        consensus?: string;
+        queen?: {
+          id?: string;
+          agentId?: string;
+          status?: string;
+          load?: number;
+          tasksQueued?: number;
         };
-        workers: Array<{
-          id: string;
-          type: string;
-          status: string;
+        workers?: Array<{
+          id?: string;
+          agentId?: string;
+          type?: string;
+          agentType?: string;
+          status?: string;
           currentTask?: string;
-          tasksCompleted: number;
-        }>;
-        metrics: {
-          totalTasks: number;
-          completedTasks: number;
-          failedTasks: number;
-          avgTaskTime: number;
-          consensusRounds: number;
-          memoryUsage: string;
+          tasksCompleted?: number;
+        } | string>;
+        metrics?: {
+          totalTasks?: number;
+          completedTasks?: number;
+          failedTasks?: number;
+          avgTaskTime?: number;
+          consensusRounds?: number;
+          memoryUsage?: string;
         };
-        health: {
-          overall: string;
-          queen: string;
-          workers: string;
-          consensus: string;
-          memory: string;
+        health?: {
+          overall?: string;
+          queen?: string;
+          workers?: string;
+          consensus?: string;
+          memory?: string;
         };
       }>('hive-mind/status', {
         includeMetrics: detailed,
@@ -318,36 +323,68 @@ const statusCommand: Command = {
         return { success: true, data: result };
       }
 
+      // Handle both simple and complex response formats - cast to flexible type
+      const flexResult = result as Record<string, unknown>;
+      const hiveId = result.hiveId ?? (flexResult.id as string) ?? 'default';
+      const status = result.status ?? ((flexResult.initialized as boolean) ? 'running' : 'stopped');
+      const queen = result.queen ?? { id: 'N/A', status: 'unknown', load: 0, tasksQueued: 0 };
+      const flexQueen = queen as Record<string, unknown>;
+      const queenId = typeof queen === 'object' ? (queen.id ?? (flexQueen.agentId as string) ?? 'N/A') : String(queen);
+      const queenLoad = typeof queen === 'object' ? (queen.load ?? 0) : 0;
+      const queenTasks = typeof queen === 'object' ? (queen.tasksQueued ?? 0) : 0;
+      const queenStatus = typeof queen === 'object' ? (queen.status ?? 'active') : 'active';
+
       output.writeln();
       output.printBox(
         [
-          `Hive ID: ${result.hiveId}`,
-          `Status: ${formatHiveStatus(result.status)}`,
-          `Topology: ${result.topology}`,
-          `Consensus: ${result.consensus}`,
+          `Hive ID: ${hiveId}`,
+          `Status: ${formatHiveStatus(String(status))}`,
+          `Topology: ${result.topology ?? 'mesh'}`,
+          `Consensus: ${result.consensus ?? 'byzantine'}`,
           '',
-          `Queen: ${result.queen.id}`,
-          `  Status: ${formatAgentStatus(result.queen.status)}`,
-          `  Load: ${(result.queen.load * 100).toFixed(1)}%`,
-          `  Queued Tasks: ${result.queen.tasksQueued}`
+          `Queen: ${queenId}`,
+          `  Status: ${formatAgentStatus(queenStatus)}`,
+          `  Load: ${(queenLoad * 100).toFixed(1)}%`,
+          `  Queued Tasks: ${queenTasks}`
         ].join('\n'),
         'Hive Mind Status'
       );
 
+      // Handle workers array - could be worker objects or just IDs
+      const workers = result.workers ?? [];
+      const workerData = Array.isArray(workers) ? workers.map(w => {
+        if (typeof w === 'string') {
+          return { id: w, type: 'worker', status: 'idle', currentTask: '-', tasksCompleted: 0 };
+        }
+        const flexWorker = w as Record<string, unknown>;
+        return {
+          id: w.id ?? (flexWorker.agentId as string) ?? 'unknown',
+          type: w.type ?? (flexWorker.agentType as string) ?? 'worker',
+          status: w.status ?? 'idle',
+          currentTask: w.currentTask ?? '-',
+          tasksCompleted: w.tasksCompleted ?? 0
+        };
+      }) : [];
+
       output.writeln();
       output.writeln(output.bold('Worker Agents'));
-      output.printTable({
-        columns: [
-          { key: 'id', header: 'ID', width: 20 },
-          { key: 'type', header: 'Type', width: 12 },
-          { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
-          { key: 'currentTask', header: 'Current Task', width: 20, format: (v: unknown) => String(v || '-') },
-          { key: 'tasksCompleted', header: 'Completed', width: 10, align: 'right' }
-        ],
-        data: result.workers
-      });
+      if (workerData.length === 0) {
+        output.printInfo('No workers in hive. Use "claude-flow hive-mind spawn" to add workers.');
+      } else {
+        output.printTable({
+          columns: [
+            { key: 'id', header: 'ID', width: 20 },
+            { key: 'type', header: 'Type', width: 12 },
+            { key: 'status', header: 'Status', width: 10, format: formatAgentStatus },
+            { key: 'currentTask', header: 'Current Task', width: 20, format: (v: unknown) => String(v || '-') },
+            { key: 'tasksCompleted', header: 'Completed', width: 10, align: 'right' }
+          ],
+          data: workerData
+        });
+      }
 
       if (detailed) {
+        const metrics = result.metrics ?? { totalTasks: 0, completedTasks: 0, failedTasks: 0, avgTaskTime: 0, consensusRounds: 0, memoryUsage: '0 MB' };
         output.writeln();
         output.writeln(output.bold('Metrics'));
         output.printTable({
@@ -356,23 +393,24 @@ const statusCommand: Command = {
             { key: 'value', header: 'Value', width: 15, align: 'right' }
           ],
           data: [
-            { metric: 'Total Tasks', value: result.metrics.totalTasks },
-            { metric: 'Completed', value: result.metrics.completedTasks },
-            { metric: 'Failed', value: result.metrics.failedTasks },
-            { metric: 'Avg Task Time', value: `${result.metrics.avgTaskTime.toFixed(1)}ms` },
-            { metric: 'Consensus Rounds', value: result.metrics.consensusRounds },
-            { metric: 'Memory Usage', value: result.metrics.memoryUsage }
+            { metric: 'Total Tasks', value: metrics.totalTasks ?? 0 },
+            { metric: 'Completed', value: metrics.completedTasks ?? 0 },
+            { metric: 'Failed', value: metrics.failedTasks ?? 0 },
+            { metric: 'Avg Task Time', value: `${(metrics.avgTaskTime ?? 0).toFixed(1)}ms` },
+            { metric: 'Consensus Rounds', value: metrics.consensusRounds ?? 0 },
+            { metric: 'Memory Usage', value: metrics.memoryUsage ?? '0 MB' }
           ]
         });
 
+        const health = result.health ?? { overall: 'healthy', queen: 'healthy', workers: 'healthy', consensus: 'healthy', memory: 'healthy' };
         output.writeln();
         output.writeln(output.bold('Health'));
         output.printList([
-          `Overall: ${formatHealth(result.health.overall)}`,
-          `Queen: ${formatHealth(result.health.queen)}`,
-          `Workers: ${formatHealth(result.health.workers)}`,
-          `Consensus: ${formatHealth(result.health.consensus)}`,
-          `Memory: ${formatHealth(result.health.memory)}`
+          `Overall: ${formatHealth(health.overall ?? 'healthy')}`,
+          `Queen: ${formatHealth(health.queen ?? 'healthy')}`,
+          `Workers: ${formatHealth(health.workers ?? 'healthy')}`,
+          `Consensus: ${formatHealth(health.consensus ?? 'healthy')}`,
+          `Memory: ${formatHealth(health.memory ?? 'healthy')}`
         ]);
       }
 
@@ -577,6 +615,129 @@ const optimizeMemoryCommand: Command = {
   }
 };
 
+// Join subcommand
+const joinCommand: Command = {
+  name: 'join',
+  description: 'Join an agent to the hive mind',
+  options: [
+    { name: 'agent-id', short: 'a', description: 'Agent ID to join', type: 'string' },
+    { name: 'role', short: 'r', description: 'Agent role (worker, specialist, scout)', type: 'string', default: 'worker' }
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const agentId = ctx.args[0] || ctx.flags['agent-id'] as string || ctx.flags.agentId as string;
+    if (!agentId) {
+      output.printError('Agent ID is required. Use --agent-id or -a flag, or provide as argument.');
+      return { success: false, exitCode: 1 };
+    }
+    try {
+      const result = await callMCPTool<{ success: boolean; agentId: string; totalWorkers: number; error?: string }>('hive-mind/join', { agentId, role: ctx.flags.role });
+      if (!result.success) { output.printError(result.error || 'Failed'); return { success: false, exitCode: 1 }; }
+      output.printSuccess(`Agent ${agentId} joined hive (${result.totalWorkers} workers)`);
+      return { success: true, data: result };
+    } catch (error) { output.printError(`Join error: ${error instanceof MCPClientError ? error.message : String(error)}`); return { success: false, exitCode: 1 }; }
+  }
+};
+
+// Leave subcommand
+const leaveCommand: Command = {
+  name: 'leave',
+  description: 'Remove an agent from the hive mind',
+  options: [{ name: 'agent-id', short: 'a', description: 'Agent ID to remove', type: 'string' }],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const agentId = ctx.args[0] || ctx.flags['agent-id'] as string || ctx.flags.agentId as string;
+    if (!agentId) { output.printError('Agent ID required.'); return { success: false, exitCode: 1 }; }
+    try {
+      const result = await callMCPTool<{ success: boolean; agentId: string; remainingWorkers: number; error?: string }>('hive-mind/leave', { agentId });
+      if (!result.success) { output.printError(result.error || 'Failed'); return { success: false, exitCode: 1 }; }
+      output.printSuccess(`Agent ${agentId} left hive (${result.remainingWorkers} remaining)`);
+      return { success: true, data: result };
+    } catch (error) { output.printError(`Leave error: ${error instanceof MCPClientError ? error.message : String(error)}`); return { success: false, exitCode: 1 }; }
+  }
+};
+
+// Consensus subcommand
+const consensusCommand: Command = {
+  name: 'consensus',
+  description: 'Manage consensus proposals and voting',
+  options: [
+    { name: 'action', short: 'a', description: 'Consensus action', type: 'string', choices: ['propose', 'vote', 'status', 'list'], default: 'list' },
+    { name: 'proposal-id', short: 'p', description: 'Proposal ID', type: 'string' },
+    { name: 'type', short: 't', description: 'Proposal type', type: 'string' },
+    { name: 'value', description: 'Proposal value', type: 'string' },
+    { name: 'vote', short: 'v', description: 'Vote (yes/no)', type: 'string' },
+    { name: 'voter-id', description: 'Voter agent ID', type: 'string' }
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const action = ctx.flags.action as string || 'list';
+    try {
+      const result = await callMCPTool<Record<string, unknown>>('hive-mind/consensus', { action, proposalId: ctx.flags.proposalId, type: ctx.flags.type, value: ctx.flags.value, vote: ctx.flags.vote === 'yes', voterId: ctx.flags.voterId });
+      if (ctx.flags.format === 'json') { output.printJson(result); return { success: true, data: result }; }
+      if (action === 'list') {
+        output.writeln(output.bold('\nPending Proposals'));
+        const pending = (result.pending as Array<Record<string, unknown>>) || [];
+        if (pending.length === 0) output.printInfo('No pending proposals');
+        else output.printTable({ columns: [{ key: 'proposalId', header: 'ID', width: 30 }, { key: 'type', header: 'Type', width: 12 }], data: pending });
+      } else if (action === 'propose') { output.printSuccess(`Proposal created: ${result.proposalId}`); }
+      else if (action === 'vote') { output.printSuccess(`Vote recorded (For: ${result.votesFor}, Against: ${result.votesAgainst})`); }
+      return { success: true, data: result };
+    } catch (error) { output.printError(`Consensus error: ${error instanceof MCPClientError ? error.message : String(error)}`); return { success: false, exitCode: 1 }; }
+  }
+};
+
+// Broadcast subcommand
+const broadcastCommand: Command = {
+  name: 'broadcast',
+  description: 'Broadcast a message to all workers in the hive',
+  options: [
+    { name: 'message', short: 'm', description: 'Message to broadcast', type: 'string', required: true },
+    { name: 'priority', short: 'p', description: 'Message priority', type: 'string', choices: ['low', 'normal', 'high', 'critical'], default: 'normal' },
+    { name: 'from', short: 'f', description: 'Sender agent ID', type: 'string' }
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const message = ctx.args.join(' ') || ctx.flags.message as string;
+    if (!message) { output.printError('Message required. Use --message or -m flag.'); return { success: false, exitCode: 1 }; }
+    try {
+      const result = await callMCPTool<{ success: boolean; messageId: string; recipients: number; error?: string }>('hive-mind/broadcast', { message, priority: ctx.flags.priority, fromId: ctx.flags.from });
+      if (!result.success) { output.printError(result.error || 'Failed'); return { success: false, exitCode: 1 }; }
+      output.printSuccess(`Message broadcast to ${result.recipients} workers (ID: ${result.messageId})`);
+      return { success: true, data: result };
+    } catch (error) { output.printError(`Broadcast error: ${error instanceof MCPClientError ? error.message : String(error)}`); return { success: false, exitCode: 1 }; }
+  }
+};
+
+// Memory subcommand
+const memorySubCommand: Command = {
+  name: 'memory',
+  description: 'Access hive shared memory',
+  options: [
+    { name: 'action', short: 'a', description: 'Memory action', type: 'string', choices: ['get', 'set', 'delete', 'list'], default: 'list' },
+    { name: 'key', short: 'k', description: 'Memory key', type: 'string' },
+    { name: 'value', short: 'v', description: 'Value to store', type: 'string' }
+  ],
+  action: async (ctx: CommandContext): Promise<CommandResult> => {
+    const action = ctx.flags.action as string || 'list';
+    const key = ctx.flags.key as string;
+    const value = ctx.flags.value as string;
+    if ((action === 'get' || action === 'delete') && !key) { output.printError('Key required for get/delete.'); return { success: false, exitCode: 1 }; }
+    if (action === 'set' && (!key || value === undefined)) { output.printError('Key and value required for set.'); return { success: false, exitCode: 1 }; }
+    try {
+      const result = await callMCPTool<Record<string, unknown>>('hive-mind/memory', { action, key, value });
+      if (ctx.flags.format === 'json') { output.printJson(result); return { success: true, data: result }; }
+      if (action === 'list') {
+        const keys = (result.keys as string[]) || [];
+        output.writeln(output.bold(`\nShared Memory (${result.count} keys)`));
+        if (keys.length === 0) output.printInfo('No keys in shared memory');
+        else output.printList(keys.map(k => output.highlight(k)));
+      } else if (action === 'get') {
+        output.writeln(output.bold(`\nKey: ${key}`));
+        output.writeln(result.exists ? `Value: ${JSON.stringify(result.value, null, 2)}` : 'Key not found');
+      } else if (action === 'set') { output.printSuccess(`Set ${key} in shared memory`); }
+      else if (action === 'delete') { output.printSuccess(result.deleted ? `Deleted ${key}` : `Key ${key} did not exist`); }
+      return { success: true, data: result };
+    } catch (error) { output.printError(`Memory error: ${error instanceof MCPClientError ? error.message : String(error)}`); return { success: false, exitCode: 1 }; }
+  }
+};
+
 // Shutdown subcommand
 const shutdownCommand: Command = {
   name: 'shutdown',
@@ -656,7 +817,7 @@ export const hiveMindCommand: Command = {
   name: 'hive-mind',
   aliases: ['hive'],
   description: 'Queen-led consensus-based multi-agent coordination',
-  subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, optimizeMemoryCommand, shutdownCommand],
+  subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
   options: [],
   examples: [
     { command: 'claude-flow hive-mind init -t hierarchical-mesh', description: 'Initialize hive' },
@@ -675,6 +836,11 @@ export const hiveMindCommand: Command = {
       `${output.highlight('spawn')}           - Spawn worker agents`,
       `${output.highlight('status')}          - Show hive status`,
       `${output.highlight('task')}            - Submit task to hive`,
+      `${output.highlight('join')}            - Join an agent to the hive`,
+      `${output.highlight('leave')}           - Remove an agent from the hive`,
+      `${output.highlight('consensus')}       - Manage consensus proposals`,
+      `${output.highlight('broadcast')}       - Broadcast message to workers`,
+      `${output.highlight('memory')}          - Access shared memory`,
       `${output.highlight('optimize-memory')} - Optimize patterns and memory`,
       `${output.highlight('shutdown')}        - Shutdown the hive`
     ]);

package/src/commands/index.ts

@@ -20,6 +20,7 @@ import { startCommand } from './start.js';
 import { statusCommand } from './status.js';
 import { taskCommand } from './task.js';
 import { sessionCommand } from './session.js';
+import { daemonCommand } from './daemon.js';
 
 // Export all commands
 export { agentCommand } from './agent.js';
@@ -38,6 +39,7 @@ export { startCommand } from './start.js';
 export { statusCommand } from './status.js';
 export { taskCommand } from './task.js';
 export { sessionCommand } from './session.js';
+export { daemonCommand } from './daemon.js';
 
 /**
  * All available commands
@@ -59,7 +61,8 @@ export const commands: Command[] = [
   hooksCommand,
   workflowCommand,
   hiveMindCommand,
-  processCommand
+  processCommand,
+  daemonCommand
 ];
 
 /**

package/src/commands/start.ts

@@ -215,8 +215,8 @@ const startAction = async (ctx: CommandContext): Promise<CommandResult> => {
       output.writeln();
       output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
 
-      // In a real implementation, this would fork a background process
-      // For now, we simulate daemon behavior
+      // Store PID for daemon management
+      // TODO: Implement proper process forking with detached: true
       const daemonPidPath = path.join(cwd, '.claude-flow', 'daemon.pid');
       fs.writeFileSync(daemonPidPath, String(process.pid));
     }

package/src/index.ts

@@ -106,6 +106,7 @@ export class CLI {
       let subcommandArgs = positional;
 
       // Process command path (e.g., ['hooks', 'worker', 'list'])
+      // Note: When parser includes subcommand in commandPath, positional already excludes it
       if (commandPath.length > 1 && command.subcommands) {
         const subcommandName = commandPath[1];
         const subcommand = command.subcommands.find(
@@ -114,7 +115,8 @@ export class CLI {
 
         if (subcommand) {
           targetCommand = subcommand;
-          subcommandArgs = positional.slice(1);
+          // Parser already extracted subcommand from positional, so use as-is
+          subcommandArgs = positional;
 
           // Check for nested subcommand (level 2)
           if (commandPath.length > 2 && subcommand.subcommands) {
@@ -124,7 +126,8 @@ export class CLI {
             );
             if (nestedSubcommand) {
               targetCommand = nestedSubcommand;
-              subcommandArgs = positional.slice(2);
+              // Parser already extracted nested subcommand too
+              subcommandArgs = positional;
             }
           }
         }

package/src/init/settings-generator.ts

@@ -50,6 +50,10 @@ export function generateSettings(options: InitOptions): object {
     neural: {
       enabled: options.runtime.enableNeural,
     },
+    daemon: {
+      autoStart: true,
+      workers: ['map', 'audit', 'optimize', 'consolidate', 'testgaps'],
+    },
   };
 
   return settings;
@@ -70,7 +74,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-edit --file "$TOOL_INPUT_file_path"',
+            command: 'npx claude-flow@v3alpha hooks pre-edit --file "$TOOL_INPUT_file_path" --intelligence',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -82,7 +86,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-command --command "$TOOL_INPUT_command"',
+            command: 'npx claude-flow@v3alpha hooks pre-command --command "$TOOL_INPUT_command"',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -94,7 +98,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-task --description "$TOOL_INPUT_prompt"',
+            command: 'npx claude-flow@v3alpha hooks pre-task --task-id "task-$(date +%s)" --description "$TOOL_INPUT_prompt"',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -106,7 +110,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-search --pattern "$TOOL_INPUT_pattern"',
+            command: 'npx claude-flow@v3alpha hooks pre-search --pattern "$TOOL_INPUT_pattern"',
             timeout: 2000,
             continueOnError: true,
           },
@@ -124,7 +128,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks post-edit --file "$TOOL_INPUT_file_path" --success "$TOOL_SUCCESS" --train-patterns',
+            command: 'npx claude-flow@v3alpha hooks post-edit --file "$TOOL_INPUT_file_path" --success "$TOOL_SUCCESS" --train-patterns',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -136,7 +140,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks post-command --command "$TOOL_INPUT_command" --success "$TOOL_SUCCESS" --exit-code "$TOOL_EXIT_CODE"',
+            command: 'npx claude-flow@v3alpha hooks post-command --command "$TOOL_INPUT_command" --success "$TOOL_SUCCESS" --exit-code "$TOOL_EXIT_CODE"',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -148,7 +152,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks post-task --agent-id "$TOOL_RESULT_agent_id" --success "$TOOL_SUCCESS" --analyze',
+            command: 'npx claude-flow@v3alpha hooks post-task --agent-id "$TOOL_RESULT_agent_id" --success "$TOOL_SUCCESS" --analyze',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -160,7 +164,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks post-search --cache-results',
+            command: 'npx claude-flow@v3alpha hooks post-search --cache-results',
             timeout: 2000,
             continueOnError: true,
           },
@@ -176,7 +180,7 @@ function generateHooksConfig(config: HooksConfig): object {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks route --task "$PROMPT" --include-explanation',
+            command: 'npx claude-flow@v3alpha hooks route --task "$PROMPT" --intelligence --include-explanation',
             timeout: config.timeout,
             continueOnError: config.continueOnError,
           },
@@ -185,14 +189,20 @@ function generateHooksConfig(config: HooksConfig): object {
     ];
   }
 
-  // SessionStart for context loading
+  // SessionStart for context loading and daemon auto-start
   if (config.sessionStart) {
     hooks.SessionStart = [
       {
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks session-start --session-id "$SESSION_ID" --load-context',
+            command: 'npx claude-flow@v3alpha daemon start --quiet 2>/dev/null || true',
+            timeout: 5000,
+            continueOnError: true,
+          },
+          {
+            type: 'command',
+            command: 'npx claude-flow@v3alpha hooks session-start --session-id "$SESSION_ID" --load-context',
             timeout: 10000,
             continueOnError: true,
           },
@@ -227,7 +237,7 @@ Respond with {"decision": "stop"} if complete, or {"decision": "continue", "reas
         hooks: [
           {
             type: 'command',
-            command: 'npx @claude-flow/cli hooks notify --message "$NOTIFICATION_MESSAGE" --swarm-status',
+            command: 'npx claude-flow@v3alpha hooks notify --message "$NOTIFICATION_MESSAGE" --swarm-status',
             timeout: 3000,
             continueOnError: true,
           },

package/src/mcp-client.ts

@@ -18,6 +18,8 @@ import { configTools } from './mcp-tools/config-tools.js';
 import { hooksTools } from './mcp-tools/hooks-tools.js';
 import { taskTools } from './mcp-tools/task-tools.js';
 import { sessionTools } from './mcp-tools/session-tools.js';
+import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
+import { workflowTools } from './mcp-tools/workflow-tools.js';
 
 /**
  * MCP Tool Registry
@@ -33,7 +35,17 @@ function registerTools(tools: MCPTool[]): void {
 }
 
 // Initialize registry with all available tools
-registerTools([...agentTools, ...swarmTools, ...memoryTools, ...configTools, ...hooksTools, ...taskTools, ...sessionTools]);
+registerTools([
+  ...agentTools,
+  ...swarmTools,
+  ...memoryTools,
+  ...configTools,
+  ...hooksTools,
+  ...taskTools,
+  ...sessionTools,
+  ...hiveMindTools,
+  ...workflowTools,
+]);
 
 /**
  * MCP Client Error