claude-flow 3.5.40 → 3.5.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.40",
+  "version": "3.5.42",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/hive-mind.js

@@ -71,36 +71,36 @@ ${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).jo
 🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
 
 1️⃣ **COLLECTIVE INTELLIGENCE**
-   mcp__claude-flow__hive-mind_consensus    - Democratic decision making
-   mcp__claude-flow__hive-mind_memory       - Share knowledge across the hive
-   mcp__claude-flow__hive-mind_broadcast    - Broadcast to all workers
-   mcp__claude-flow__neural_patterns        - Neural pattern recognition
+   mcp__ruflo__hive-mind_consensus    - Democratic decision making
+   mcp__ruflo__hive-mind_memory       - Share knowledge across the hive
+   mcp__ruflo__hive-mind_broadcast    - Broadcast to all workers
+   mcp__ruflo__neural_patterns        - Neural pattern recognition
 
 2️⃣ **QUEEN COORDINATION**
-   mcp__claude-flow__hive-mind_status       - Monitor swarm health
-   mcp__claude-flow__task_create            - Create and delegate tasks
-   mcp__claude-flow__task_orchestrate       - Orchestrate task distribution
-   mcp__claude-flow__agent_spawn            - Spawn additional workers
+   mcp__ruflo__hive-mind_status       - Monitor swarm health
+   mcp__ruflo__task_create            - Create and delegate tasks
+   mcp__ruflo__coordination_orchestrate - Orchestrate task distribution
+   mcp__ruflo__agent_spawn            - Spawn additional workers
 
 3️⃣ **WORKER MANAGEMENT**
-   mcp__claude-flow__agent_list             - List all active agents
-   mcp__claude-flow__agent_status           - Check agent status
-   mcp__claude-flow__agent_metrics          - Track worker performance
-   mcp__claude-flow__hive-mind_join         - Add agent to hive
-   mcp__claude-flow__hive-mind_leave        - Remove agent from hive
+   mcp__ruflo__agent_list             - List all active agents
+   mcp__ruflo__agent_status           - Check agent status
+   mcp__ruflo__agent_health           - Check worker health
+   mcp__ruflo__hive-mind_join         - Add agent to hive
+   mcp__ruflo__hive-mind_leave        - Remove agent from hive
 
 4️⃣ **TASK ORCHESTRATION**
-   mcp__claude-flow__task_create            - Create hierarchical tasks
-   mcp__claude-flow__task_status            - Track task progress
-   mcp__claude-flow__task_complete          - Mark tasks complete
-   mcp__claude-flow__workflow_create        - Create workflows
+   mcp__ruflo__task_assign            - Assign tasks to workers
+   mcp__ruflo__task_status            - Track task progress
+   mcp__ruflo__task_complete          - Mark tasks complete
+   mcp__ruflo__workflow_create        - Create workflows
 
 5️⃣ **MEMORY & LEARNING**
-   mcp__claude-flow__memory_store           - Store collective knowledge
-   mcp__claude-flow__memory_retrieve        - Access shared memory
-   mcp__claude-flow__memory_search          - Search memory patterns
-   mcp__claude-flow__neural_train           - Learn from experiences
-   mcp__claude-flow__hooks_intelligence_pattern-store - Store patterns
+   mcp__ruflo__memory_store           - Store collective knowledge
+   mcp__ruflo__memory_retrieve        - Access shared memory
+   mcp__ruflo__memory_search          - Search memory patterns
+   mcp__ruflo__neural_train           - Learn from experiences
+   mcp__ruflo__hooks_intelligence_pattern-store - Store patterns
 
 📋 HIVE MIND EXECUTION PROTOCOL:
 
@@ -132,11 +132,11 @@ ${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).jo
 ${objective}
 
 💡 COORDINATION TIPS:
-• Use mcp__claude-flow__hive-mind_broadcast for swarm-wide announcements
-• Check worker status regularly with mcp__claude-flow__hive-mind_status
+• Use mcp__ruflo__hive-mind_broadcast for swarm-wide announcements
+• Check worker status regularly with mcp__ruflo__hive-mind_status
 • Store important decisions in shared memory for persistence
 • Use consensus for any decisions affecting multiple workers
-• Monitor task progress and reassign if workers are blocked
+• Use mcp__ruflo__task_assign to assign tasks to workers, then mcp__ruflo__task_complete when done
 
 🚀 BEGIN HIVE MIND COORDINATION NOW!
 Start by checking the current hive status and then proceed with the objective.

package/v3/@claude-flow/cli/dist/src/mcp-server.js

@@ -252,7 +252,7 @@ export class MCPServerManager extends EventEmitter {
             method: 'server.initialized',
             params: {
                 serverInfo: {
-                    name: 'claude-flow',
+                    name: 'ruflo',
                     version: VERSION,
                     capabilities: {
                         tools: { listChanged: true },
@@ -330,7 +330,7 @@ export class MCPServerManager extends EventEmitter {
                         id: message.id,
                         result: {
                             protocolVersion: '2024-11-05',
-                            serverInfo: { name: 'claude-flow', version: '3.0.0' },
+                            serverInfo: { name: 'ruflo', version: '3.0.0' },
                             capabilities: {
                                 tools: { listChanged: true },
                                 resources: { subscribe: true, listChanged: true },

package/v3/@claude-flow/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -253,6 +253,29 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const uptime = state.createdAt ? Date.now() - new Date(state.createdAt).getTime() : 0;
+            // Load agent store once for all workers
+            const agentStore = loadAgentStore();
+            // Compute real task metrics from task store
+            const taskStorePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
+            let pendingTaskCount = 0;
+            let activeTaskCount = 0;
+            let completedTaskCount = 0;
+            try {
+                if (existsSync(taskStorePath)) {
+                    const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
+                    for (const task of Object.values(taskStore.tasks || {})) {
+                        if (task.status === 'pending')
+                            pendingTaskCount++;
+                        else if (task.status === 'in_progress')
+                            activeTaskCount++;
+                        else if (task.status === 'completed')
+                            completedTaskCount++;
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            const workerCount = Math.max(1, state.workers.length);
+            const realLoad = activeTaskCount / workerCount;
             const status = {
                 // CLI expected fields
                 hiveId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
@@ -263,23 +286,27 @@ export const hiveMindTools = [
                     id: state.queen.agentId,
                     agentId: state.queen.agentId,
                     status: 'active',
-                    load: 0.3 + Math.random() * 0.4, // Simulated load
-                    tasksQueued: state.consensus.pending.length,
+                    load: Math.round(realLoad * 1000) / 1000,
+                    tasksQueued: pendingTaskCount,
                     electedAt: state.queen.electedAt,
                     term: state.queen.term,
                 } : { id: 'N/A', status: 'offline', load: 0, tasksQueued: 0 },
-                workers: state.workers.map(w => ({
-                    id: w,
-                    type: 'worker',
-                    status: 'idle',
-                    currentTask: null,
-                    tasksCompleted: 0,
-                })),
+                workers: state.workers.map(w => {
+                    const agent = agentStore.agents[w];
+                    return {
+                        id: w,
+                        type: agent?.agentType || 'worker',
+                        status: agent?.status || 'unknown',
+                        currentTask: agent?.currentTask || null,
+                        tasksCompleted: agent?.taskCount || 0,
+                    };
+                }),
                 metrics: {
-                    totalTasks: state.consensus.history.length + state.consensus.pending.length,
-                    completedTasks: state.consensus.history.length,
+                    totalTasks: pendingTaskCount + activeTaskCount + completedTaskCount,
+                    completedTasks: completedTaskCount,
+                    activeTasks: activeTaskCount,
+                    pendingTasks: pendingTaskCount,
                     failedTasks: 0,
-                    avgTaskTime: 150,
                     consensusRounds: state.consensus.history.length,
                     memoryUsage: `${Object.keys(state.sharedMemory).length * 2} KB`,
                 },

package/v3/@claude-flow/cli/dist/src/mcp-tools/memory-tools.js

@@ -157,10 +157,20 @@ export const memoryTools = [
             const { storeEntry } = await getMemoryFunctions();
             const key = input.key;
             const namespace = input.namespace || 'default';
-            const value = typeof input.value === 'string' ? input.value : JSON.stringify(input.value);
+            const rawValue = input.value;
+            const value = typeof rawValue === 'string' ? rawValue : (rawValue !== undefined ? JSON.stringify(rawValue) : '');
             const tags = input.tags || [];
             const ttl = input.ttl;
             const upsert = input.upsert || false;
+            if (!value) {
+                return {
+                    success: false,
+                    key,
+                    stored: false,
+                    hasEmbedding: false,
+                    error: 'Value is required and cannot be empty',
+                };
+            }
             validateMemoryInput(key, value);
             const startTime = performance.now();
             try {

package/v3/@claude-flow/cli/dist/src/mcp-tools/task-tools.js

@@ -201,6 +201,28 @@ export const taskTools = [
                 task.completedAt = new Date().toISOString();
                 task.result = input.result || {};
                 saveTaskStore(store);
+                // Sync assigned agents back to idle and increment taskCount
+                if (task.assignedTo.length > 0) {
+                    const agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
+                    try {
+                        let agentStore = { agents: {} };
+                        if (existsSync(agentStorePath)) {
+                            agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                        }
+                        for (const agentId of task.assignedTo) {
+                            if (agentStore.agents[agentId]) {
+                                agentStore.agents[agentId].status = 'idle';
+                                agentStore.agents[agentId].currentTask = null;
+                                agentStore.agents[agentId].taskCount =
+                                    (agentStore.agents[agentId].taskCount || 0) + 1;
+                            }
+                        }
+                        writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
+                    }
+                    catch {
+                        // Best-effort agent sync
+                    }
+                }
                 return {
                     taskId: task.taskId,
                     status: task.status,
@@ -284,18 +306,62 @@ export const taskTools = [
                 return { taskId, error: 'Task not found' };
             }
             const previouslyAssigned = [...task.assignedTo];
+            // Load agent store to sync worker state
+            const agentStorePath = join(process.cwd(), STORAGE_DIR, 'agents.json');
+            let agentStore = { agents: {} };
+            try {
+                if (existsSync(agentStorePath)) {
+                    agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                }
+            }
+            catch { /* ignore */ }
             if (input.unassign) {
+                // Revert previously assigned agents to idle
+                for (const agentId of previouslyAssigned) {
+                    if (agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'idle';
+                        agentStore.agents[agentId].currentTask = null;
+                    }
+                }
                 task.assignedTo = [];
             }
             else {
                 const agentIds = input.agentIds || [];
+                // Revert old agents to idle
+                for (const agentId of previouslyAssigned) {
+                    if (!agentIds.includes(agentId) && agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'idle';
+                        agentStore.agents[agentId].currentTask = null;
+                    }
+                }
+                // Set new agents to active
+                for (const agentId of agentIds) {
+                    if (agentStore.agents[agentId]) {
+                        agentStore.agents[agentId].status = 'active';
+                        agentStore.agents[agentId].currentTask = taskId;
+                    }
+                }
                 task.assignedTo = agentIds;
+                // Auto-transition task to in_progress if pending
+                if (task.status === 'pending' && agentIds.length > 0) {
+                    task.status = 'in_progress';
+                    if (!task.startedAt) {
+                        task.startedAt = new Date().toISOString();
+                    }
+                }
             }
             saveTaskStore(store);
+            // Save agent store
+            const agentDir = join(process.cwd(), STORAGE_DIR);
+            if (!existsSync(agentDir)) {
+                mkdirSync(agentDir, { recursive: true });
+            }
+            writeFileSync(agentStorePath, JSON.stringify(agentStore, null, 2), 'utf-8');
             return {
                 taskId: task.taskId,
                 assignedTo: task.assignedTo,
                 previouslyAssigned,
+                status: task.status,
             };
         },
     },

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.40",
+  "version": "3.5.42",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",