claude-flow 3.5.3 → 3.5.4

package/.claude/helpers/auto-memory-hook.mjs

@@ -139,17 +139,30 @@ async function loadMemoryPackage() {
     } catch { /* fall through */ }
   }
 
-  // Strategy 2: npm installed @claude-flow/memory
+  // Strategy 2: Use createRequire for CJS-style resolution (handles nested node_modules
+  // when installed as a transitive dependency via npx ruflo / npx claude-flow)
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
+    return require('@claude-flow/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 3: ESM import (works when @claude-flow/memory is a direct dependency)
   try {
     return await import('@claude-flow/memory');
   } catch { /* fall through */ }
 
-  // Strategy 3: Installed via @claude-flow/cli which includes memory
-  const cliMemory = join(PROJECT_ROOT, 'node_modules/@claude-flow/memory/dist/index.js');
-  if (existsSync(cliMemory)) {
-    try {
-      return await import(`file://${cliMemory}`);
-    } catch { /* fall through */ }
+  // Strategy 4: Walk up from PROJECT_ROOT looking for @claude-flow/memory in any node_modules
+  let searchDir = PROJECT_ROOT;
+  const { parse } = await import('path');
+  while (searchDir !== parse(searchDir).root) {
+    const candidate = join(searchDir, 'node_modules', '@claude-flow', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try {
+        return await import(`file://${candidate}`);
+      } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
   }
 
   return null;

package/.claude/helpers/hook-handler.cjs

@@ -36,7 +36,30 @@ const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
 const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
 
 const [,, command, ...args] = process.argv;
-const prompt = process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';
+
+// Read stdin — Claude Code sends hook data as JSON via stdin
+async function readStdin() {
+  if (process.stdin.isTTY) return '';
+  let data = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) {
+    data += chunk;
+  }
+  return data;
+}
+
+async function main() {
+  let stdinData = '';
+  try { stdinData = await readStdin(); } catch (e) { /* ignore stdin errors */ }
+
+  let hookInput = {};
+  if (stdinData.trim()) {
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore parse errors */ }
+  }
+
+  // Merge stdin data into prompt resolution: prefer stdin fields, then env, then argv
+  const prompt = hookInput.prompt || hookInput.command || hookInput.toolInput
+    || process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';
 
 const handlers = {
   'route': () => {
@@ -63,7 +86,7 @@ const handlers = {
   },
 
   'pre-bash': () => {
-    var cmd = prompt.toLowerCase();
+    var cmd = (hookInput.command || prompt).toLowerCase();
     var dangerous = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:'];
     for (var i = 0; i < dangerous.length; i++) {
       if (cmd.includes(dangerous[i])) {
@@ -80,7 +103,8 @@ const handlers = {
     }
     if (intelligence && intelligence.recordEdit) {
       try {
-        var file = process.env.TOOL_INPUT_file_path || args[0] || '';
+        var file = hookInput.file_path || (hookInput.toolInput && hookInput.toolInput.file_path)
+          || process.env.TOOL_INPUT_file_path || args[0] || '';
         intelligence.recordEdit(file);
       } catch (e) { /* non-fatal */ }
     }
@@ -179,13 +203,18 @@ const handlers = {
 };
 
 if (command && handlers[command]) {
-  try {
-    handlers[command]();
-  } catch (e) {
-    console.log('[WARN] Hook ' + command + ' encountered an error: ' + e.message);
+    try {
+      handlers[command]();
+    } catch (e) {
+      console.log('[WARN] Hook ' + command + ' encountered an error: ' + e.message);
+    }
+  } else if (command) {
+    console.log('[OK] Hook: ' + command);
+  } else {
+    console.log('Usage: hook-handler.cjs <route|pre-bash|post-edit|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');
   }
-} else if (command) {
-  console.log('[OK] Hook: ' + command);
-} else {
-  console.log('Usage: hook-handler.cjs <route|pre-bash|post-edit|session-restore|session-end|pre-task|post-task|compact-manual|compact-auto|status|stats>');
 }
+
+main().catch(function(e) {
+  console.log('[WARN] Hook handler error: ' + e.message);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "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/doctor.js

@@ -192,10 +192,15 @@ async function checkDiskSpace() {
         if (process.platform === 'win32') {
             return { name: 'Disk Space', status: 'pass', message: 'Check skipped on Windows' };
         }
-        const output_str = await runCommand('df -h . | tail -1');
+        // Use df -Ph for POSIX mode (guarantees single-line output even with long device names)
+        const output_str = await runCommand('df -Ph . | tail -1');
         const parts = output_str.split(/\s+/);
+        // POSIX format: Filesystem Size Used Avail Capacity Mounted
         const available = parts[3];
         const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
+        if (isNaN(usePercent)) {
+            return { name: 'Disk Space', status: 'warn', message: `${available || 'unknown'} available (unable to parse usage)` };
+        }
         if (usePercent > 90) {
             return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
         }

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

@@ -247,7 +247,19 @@ const statusCommand = {
     description: 'Show MCP server status',
     action: async (ctx) => {
         try {
-            const status = await getMCPServerStatus();
+            let status = await getMCPServerStatus();
+            // If PID-based check says not running, detect stdio mode
+            if (!status.running) {
+                const isStdio = !process.stdin.isTTY;
+                const envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+                if (isStdio || envTransport === 'stdio') {
+                    status = {
+                        running: true,
+                        pid: process.pid,
+                        transport: 'stdio',
+                    };
+                }
+            }
             if (ctx.flags.format === 'json') {
                 output.printJson(status);
                 return { success: true, data: status };
@@ -273,9 +285,12 @@ const statusCommand = {
                 { metric: 'Status', value: output.success('Running') },
                 { metric: 'PID', value: status.pid },
                 { metric: 'Transport', value: status.transport },
-                { metric: 'Host', value: status.host },
-                { metric: 'Port', value: status.port },
             ];
+            // Only show host/port for non-stdio transports
+            if (status.transport !== 'stdio') {
+                displayData.push({ metric: 'Host', value: status.host });
+                displayData.push({ metric: 'Port', value: status.port });
+            }
             if (status.uptime !== undefined) {
                 displayData.push({ metric: 'Uptime', value: formatUptime(status.uptime) });
             }

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

@@ -223,7 +223,12 @@ function displayStatus(status) {
     // MCP section
     output.writeln(output.bold('MCP Server'));
     if (status.mcp.running) {
-        output.printInfo(`  Running on port ${status.mcp.port} (${status.mcp.transport})`);
+        if (status.mcp.transport === 'stdio') {
+            output.printInfo('  Running (stdio mode)');
+        }
+        else {
+            output.printInfo(`  Running on port ${status.mcp.port} (${status.mcp.transport})`);
+        }
     }
     else {
         output.printInfo('  Not running');
@@ -316,7 +321,9 @@ async function performHealthCheck(status) {
         checks.push({
             name: 'MCP Server',
             status: status.mcp.running ? 'pass' : 'warn',
-            message: status.mcp.running ? `Running on port ${status.mcp.port}` : 'Not running'
+            message: status.mcp.running
+                ? (status.mcp.transport === 'stdio' ? 'Running (stdio mode)' : `Running on port ${status.mcp.port}`)
+                : 'Not running'
         });
         // Check memory backend
         checks.push({

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -794,10 +794,34 @@ const dim = (msg) => console.log(\`  \${DIM}\${msg}\${RESET}\`);
 // Ensure data dir
 if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
 
+async function loadMemoryPackage() {
+  // Strategy 1: Use createRequire for CJS-style resolution (handles nested node_modules
+  // when installed as a transitive dependency via npx ruflo / npx claude-flow)
+  try {
+    const { createRequire } = await import('module');
+    const require = createRequire(join(PROJECT_ROOT, 'package.json'));
+    return require('@claude-flow/memory');
+  } catch { /* fall through */ }
+
+  // Strategy 2: ESM import (works when @claude-flow/memory is a direct dependency)
+  try { return await import('@claude-flow/memory'); } catch { /* fall through */ }
+
+  // Strategy 3: Walk up from PROJECT_ROOT looking for the package in any node_modules
+  let searchDir = PROJECT_ROOT;
+  const { parse } = await import('path');
+  while (searchDir !== parse(searchDir).root) {
+    const candidate = join(searchDir, 'node_modules', '@claude-flow', 'memory', 'dist', 'index.js');
+    if (existsSync(candidate)) {
+      try { return await import(\`file://\${candidate}\`); } catch { /* fall through */ }
+    }
+    searchDir = dirname(searchDir);
+  }
+
+  return null;
+}
+
 async function doImport() {
-  // Try loading @claude-flow/memory for full functionality
-  let memPkg = null;
-  try { memPkg = await import('@claude-flow/memory'); } catch {}
+  const memPkg = await loadMemoryPackage();
 
   if (!memPkg || !memPkg.AutoMemoryBridge) {
     dim('Memory package not available — auto memory import skipped (non-critical)');
@@ -814,8 +838,7 @@ async function doSync() {
     return;
   }
 
-  let memPkg = null;
-  try { memPkg = await import('@claude-flow/memory'); } catch {}
+  const memPkg = await loadMemoryPackage();
 
   if (!memPkg || !memPkg.AutoMemoryBridge) {
     dim('Memory package not available — sync skipped (non-critical)');

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

@@ -142,6 +142,21 @@ export class MCPServerManager extends EventEmitter {
         // Check PID file
         const pid = await this.readPidFile();
         if (!pid) {
+            // No PID file found. Detect if we are running in stdio mode
+            // (e.g., launched by Claude Code via `claude mcp add`).
+            const isStdio = !process.stdin.isTTY;
+            const envTransport = process.env.CLAUDE_FLOW_MCP_TRANSPORT;
+            if (isStdio || envTransport === 'stdio' || this.options.transport === 'stdio') {
+                return {
+                    running: true,
+                    pid: process.pid,
+                    transport: 'stdio',
+                    startedAt: this.startTime?.toISOString(),
+                    uptime: this.startTime
+                        ? Math.floor((Date.now() - this.startTime.getTime()) / 1000)
+                        : undefined,
+                };
+            }
             return { running: false };
         }
         // Check if process is running
@@ -459,6 +474,7 @@ export class MCPServerManager extends EventEmitter {
                 this.emit('health-error', error);
             }
         }, 30000);
+        this.healthCheckInterval.unref();
     }
     /**
      * Write PID file

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

@@ -512,12 +512,32 @@ export const hooksPostEdit = {
     handler: async (params) => {
         const filePath = params.filePath;
         const success = params.success !== false;
+        const agent = params.agent;
+        // Wire recordFeedback through bridge (issue #1209)
+        let feedbackResult = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            feedbackResult = await bridge.bridgeRecordFeedback({
+                taskId: `edit-${filePath}-${Date.now()}`,
+                success,
+                quality: success ? 0.85 : 0.3,
+                agent,
+            });
+        }
+        catch {
+            // Bridge not available — continue with basic response
+        }
         return {
             recorded: true,
             filePath,
             success,
             timestamp: new Date().toISOString(),
             learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
+            feedback: feedbackResult ? {
+                recorded: feedbackResult.success,
+                controller: feedbackResult.controller,
+                updates: feedbackResult.updated,
+            } : { recorded: false, controller: 'unavailable', updates: 0 },
         };
     },
 };

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

@@ -325,5 +325,93 @@ export const systemTools = [
             };
         },
     },
+    {
+        name: 'mcp_status',
+        description: 'Get MCP server status, including stdio mode detection',
+        category: 'system',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            // Detect if we are running inside an MCP stdio session.
+            // When Claude Code launches us via `claude mcp add`, stdin is piped (not a TTY)
+            // and the process IS the MCP server, so it is running.
+            const isStdio = !process.stdin.isTTY;
+            const transport = process.env.CLAUDE_FLOW_MCP_TRANSPORT || (isStdio ? 'stdio' : 'http');
+            const port = parseInt(process.env.CLAUDE_FLOW_MCP_PORT || '3000', 10);
+            if (transport === 'stdio' || isStdio) {
+                // In stdio mode the MCP server is this process itself
+                return {
+                    running: true,
+                    pid: process.pid,
+                    transport: 'stdio',
+                    port: null,
+                    host: null,
+                };
+            }
+            // For HTTP/WebSocket, try to check if the server is listening
+            const host = process.env.CLAUDE_FLOW_MCP_HOST || 'localhost';
+            try {
+                const { createConnection } = await import('node:net');
+                const connected = await new Promise((resolve) => {
+                    const socket = createConnection({ host, port }, () => {
+                        socket.destroy();
+                        resolve(true);
+                    });
+                    socket.on('error', () => resolve(false));
+                    socket.setTimeout(2000, () => {
+                        socket.destroy();
+                        resolve(false);
+                    });
+                });
+                return {
+                    running: connected,
+                    transport,
+                    port,
+                    host,
+                };
+            }
+            catch {
+                return {
+                    running: false,
+                    transport,
+                    port,
+                    host,
+                };
+            }
+        },
+    },
+    {
+        name: 'task_summary',
+        description: 'Get a summary of all tasks by status',
+        category: 'task',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            // Read from the task store file
+            const storePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
+            let tasks = [];
+            try {
+                if (existsSync(storePath)) {
+                    const data = readFileSync(storePath, 'utf-8');
+                    const store = JSON.parse(data);
+                    tasks = Object.values(store.tasks || {});
+                }
+            }
+            catch {
+                // empty store
+            }
+            return {
+                total: tasks.length,
+                pending: tasks.filter(t => t.status === 'pending').length,
+                running: tasks.filter(t => t.status === 'in_progress').length,
+                completed: tasks.filter(t => t.status === 'completed').length,
+                failed: tasks.filter(t => t.status === 'failed').length,
+            };
+        },
+    },
 ];
 //# sourceMappingURL=system-tools.js.map

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

@@ -263,6 +263,42 @@ export const taskTools = [
             };
         },
     },
+    {
+        name: 'task_assign',
+        description: 'Assign a task to one or more agents',
+        category: 'task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'Task ID to assign' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
+                unassign: { type: 'boolean', description: 'Unassign all agents from task' },
+            },
+            required: ['taskId'],
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (!task) {
+                return { taskId, error: 'Task not found' };
+            }
+            const previouslyAssigned = [...task.assignedTo];
+            if (input.unassign) {
+                task.assignedTo = [];
+            }
+            else {
+                const agentIds = input.agentIds || [];
+                task.assignedTo = agentIds;
+            }
+            saveTaskStore(store);
+            return {
+                taskId: task.taskId,
+                assignedTo: task.assignedTo,
+                previouslyAssigned,
+            };
+        },
+    },
     {
         name: 'task_cancel',
         description: 'Cancel a task',

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

@@ -39,6 +39,97 @@ function saveWorkflowStore(store) {
     writeFileSync(getWorkflowPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
 export const workflowTools = [
+    {
+        name: 'workflow_run',
+        description: 'Run a workflow from a template or file',
+        category: 'workflow',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name to run' },
+                file: { type: 'string', description: 'Workflow file path' },
+                task: { type: 'string', description: 'Task description' },
+                options: {
+                    type: 'object',
+                    description: 'Workflow options',
+                    properties: {
+                        parallel: { type: 'boolean', description: 'Run stages in parallel' },
+                        maxAgents: { type: 'number', description: 'Maximum agents to use' },
+                        timeout: { type: 'number', description: 'Timeout in seconds' },
+                        dryRun: { type: 'boolean', description: 'Validate without executing' },
+                    },
+                },
+            },
+        },
+        handler: async (input) => {
+            const store = loadWorkflowStore();
+            const template = input.template;
+            const task = input.task;
+            const options = input.options || {};
+            const dryRun = options.dryRun;
+            // Build workflow from template or inline
+            const workflowId = `workflow-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const stages = [];
+            // Generate stages based on template
+            const templateName = template || 'custom';
+            const stageNames = (() => {
+                switch (templateName) {
+                    case 'feature':
+                        return ['Research', 'Design', 'Implement', 'Test', 'Review'];
+                    case 'bugfix':
+                        return ['Investigate', 'Fix', 'Test', 'Review'];
+                    case 'refactor':
+                        return ['Analyze', 'Refactor', 'Test', 'Review'];
+                    case 'security':
+                        return ['Scan', 'Analyze', 'Report'];
+                    default:
+                        return ['Execute'];
+                }
+            })();
+            for (const name of stageNames) {
+                stages.push({
+                    name,
+                    status: dryRun ? 'validated' : 'pending',
+                    agents: [],
+                });
+            }
+            if (!dryRun) {
+                // Create and save the workflow
+                const steps = stageNames.map((name, i) => ({
+                    stepId: `step-${i + 1}`,
+                    name,
+                    type: 'task',
+                    config: { task: task || name },
+                    status: 'pending',
+                }));
+                const workflow = {
+                    workflowId,
+                    name: task || `${templateName} workflow`,
+                    description: task,
+                    steps,
+                    status: 'running',
+                    currentStep: 0,
+                    variables: { template: templateName, ...options },
+                    createdAt: new Date().toISOString(),
+                    startedAt: new Date().toISOString(),
+                };
+                store.workflows[workflowId] = workflow;
+                saveWorkflowStore(store);
+            }
+            return {
+                workflowId,
+                template: templateName,
+                status: dryRun ? 'validated' : 'running',
+                stages,
+                metrics: {
+                    totalStages: stages.length,
+                    completedStages: 0,
+                    agentsSpawned: 0,
+                    estimatedDuration: `${stages.length * 30}s`,
+                },
+            };
+        },
+    },
     {
         name: 'workflow_create',
         description: 'Create a new workflow',

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

@@ -83,6 +83,7 @@ async function getRegistry(dbPath) {
                             tieredCache: true,
                             hierarchicalMemory: true,
                             memoryConsolidation: true,
+                            memoryGraph: true, // issue #1214: enable MemoryGraph for graph-aware ranking
                         },
                     });
                 }

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

@@ -481,6 +481,7 @@ export class Spinner {
             this.render();
             this.frameIndex = (this.frameIndex + 1) % this.frames.length;
         }, 100);
+        this.interval.unref();
         this.render();
     }
     stop(message) {

package/v3/@claude-flow/cli/dist/src/services/container-worker-pool.js

@@ -481,6 +481,7 @@ export class ContainerWorkerPool extends EventEmitter {
         this.healthCheckTimer = setInterval(async () => {
             await this.runHealthChecks();
         }, this.config.healthCheckIntervalMs);
+        this.healthCheckTimer.unref();
     }
     /**
      * Run health checks on all containers
@@ -522,6 +523,7 @@ export class ContainerWorkerPool extends EventEmitter {
         this.idleCheckTimer = setInterval(async () => {
             await this.runIdleChecks();
         }, 60000); // Check every minute
+        this.idleCheckTimer.unref();
     }
     /**
      * Terminate idle containers above minimum

package/v3/@claude-flow/cli/dist/src/services/worker-queue.js

@@ -57,6 +57,7 @@ class InMemoryStore {
         if (this.cleanupTimer)
             return;
         this.cleanupTimer = setInterval(() => this.cleanupExpired(), 60000);
+        this.cleanupTimer.unref();
     }
     /**
      * Stop cleanup timer
@@ -495,6 +496,7 @@ export class WorkerQueue extends EventEmitter {
                 this.store.setWorker(this.workerId, registration);
             }
         }, this.config.heartbeatIntervalMs);
+        this.heartbeatTimer.unref();
     }
     /**
      * Stop heartbeat timer

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "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",