claude-flow 3.10.40 → 3.10.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.10.40",
+  "version": "3.10.41",
   "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

@@ -306,7 +306,20 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             output.printSuccess('Claude Code launched with Hive Mind coordination');
             output.printInfo('The Queen coordinator will orchestrate all worker agents');
             output.writeln(output.dim(`Prompt file saved at: ${promptFile}`));
-            return { success: true, promptFile };
+            // #2297: await child exit before returning. Without this, the CLI
+            // process resolves immediately, finishes, and the still-initializing
+            // `claude` child loses its controlling terminal and is killed mid-launch
+            // — visible as a stray XTVERSION reply leaking onto the next shell
+            // prompt (the terminal queried for capabilities, but the child died
+            // before reading the answer). Awaiting also makes the existing
+            // claudeProcess.on('exit', ...) log lines actually print, and lets the
+            // non-interactive (-p / --non-interactive) path complete only after
+            // Claude Code finishes.
+            const claudeExitCode = await new Promise((resolve) => {
+                claudeProcess.on('exit', (c) => resolve(c ?? 0));
+                claudeProcess.on('error', () => resolve(1));
+            });
+            return { success: claudeExitCode === 0, promptFile };
         }
         else if (dryRun) {
             output.writeln();

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

@@ -1560,6 +1560,19 @@ const postTaskCommand = {
             short: 'a',
             description: 'Agent that executed the task',
             type: 'string'
+        },
+        {
+            // ADR-147 P2: nested-subagent spawn-tree capture
+            name: 'parent-agent-id',
+            description: 'ID of the parent agent (from Claude Code\'s parent_agent_id OTel span tag). Omit for top-level work.',
+            type: 'string',
+            required: false
+        },
+        {
+            name: 'depth',
+            description: 'Chain depth from root lead session (0 = lead, 1+ = subagent). Used by ADR-147 P3 depth-aware guardrail.',
+            type: 'number',
+            required: false
         }
     ],
     examples: [
@@ -1579,6 +1592,9 @@ const postTaskCommand = {
                 quality: ctx.flags.quality,
                 agent: ctx.flags.agent,
                 timestamp: Date.now(),
+                // ADR-147 P2: forward spawn-tree lineage if caller supplied it
+                parentAgentId: ctx.flags.parentAgentId,
+                depth: ctx.flags.depth,
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);

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

@@ -65,10 +65,51 @@ const CONFIG = {
 const CWD = process.cwd();
 
 // ─── Delegation cache ───────────────────────────────────────────
-// Cache the CLI JSON result for 10s so rapid prompt re-renders
-// (e.g. every keypress in some shells) don't re-invoke npx each time.
+// Cache the CLI JSON result for 60s so rapid prompt re-renders
+// (Claude Code refreshes the statusline several times a second while
+// streaming) don't re-invoke the CLI each time. #2337: bumped 10s→60s
+// because 10s was far too short for how often Claude Code re-renders.
 const CACHE_FILE = path.join(os.tmpdir(), 'ruflo-statusline-cache-' + require('crypto').createHash('md5').update(CWD).digest('hex').slice(0, 8) + '.json');
-const CACHE_TTL_MS = 10000;
+const CACHE_TTL_MS = 60000;
+
+// #2337: resolve an already-installed @claude-flow/cli (or ruflo) bin so we
+// can invoke it directly via \`node\`. The previous version called
+// \`npx --yes @claude-flow/cli@latest\` on every uncached render, which forces
+// a registry resolution + cold-start of the entire CLI per render. With
+// multiple concurrent Claude Code sessions this storms the host (reporter
+// saw load average 40-65 on a 12-core box).
+//
+// Returns the absolute path to bin/cli.js or null. Mirrors getPkgVersion()'s
+// path probing (project, monorepo, plugin marketplace, global node_modules
+// including custom-prefix layouts like ~/.npm-global).
+function resolveCliBin() {
+  try {
+    const home = os.homedir();
+    const candidates = [
+      path.join(home, '.claude', 'plugins', 'marketplaces', 'ruflo', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', '@claude-flow', 'cli', 'bin', 'cli.js'),
+      path.join(CWD, 'node_modules', 'ruflo', 'bin', 'cli.js'),
+      path.join(CWD, 'v3', '@claude-flow', 'cli', 'bin', 'cli.js'),
+    ];
+    try {
+      const binDir = path.dirname(process.execPath);
+      const globalModuleDirs = [path.join(binDir, '..', 'lib', 'node_modules'), path.join(binDir, 'node_modules')];
+      for (const prefix of [process.env.npm_config_prefix, process.env.PREFIX, path.join(home, '.npm-global')]) {
+        if (prefix) globalModuleDirs.push(path.join(prefix, 'lib', 'node_modules'));
+      }
+      for (const gm of globalModuleDirs) {
+        candidates.push(
+          path.join(gm, 'ruflo', 'bin', 'cli.js'),
+          path.join(gm, '@claude-flow', 'cli', 'bin', 'cli.js'),
+        );
+      }
+    } catch { /* ignore */ }
+    for (const p of candidates) {
+      if (fs.existsSync(p)) return p;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
 
 function readCache() {
   try {
@@ -99,8 +140,16 @@ function getStatuslineData() {
   if (cached) return cached;
 
   try {
+    // #2337: prefer an already-installed CLI bin via direct \`node\` invocation
+    // — no npx, no registry round-trip, no @latest re-resolve per render.
+    // Fall back to \`npx --prefer-offline @claude-flow/cli\` (no @latest) only
+    // when nothing is installed locally, so a cold environment still works.
+    const cliBin = resolveCliBin();
+    const cmd = cliBin
+      ? '"' + process.execPath + '" "' + cliBin + '" hooks statusline --json 2>/dev/null'
+      : 'npx --prefer-offline @claude-flow/cli hooks statusline --json 2>/dev/null';
     const raw = execSync(
-      'npx --yes @claude-flow/cli@latest hooks statusline --json 2>/dev/null',
+      cmd,
       { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD }
     ).trim();
     // The CLI may emit preamble lines before the JSON — find the first '{'.

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

@@ -1239,6 +1239,9 @@ export const hooksPostTask = {
             quality: { type: 'number', description: 'Quality score (0-1)' },
             task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
             storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
+            // ADR-147 P2: nested-subagent spawn-tree capture
+            parentAgentId: { type: 'string', description: 'ID of the parent agent (from Claude Code\'s parent_agent_id OTel span tag / x-claude-code-parent-agent-id header). Omit for top-level work.' },
+            depth: { type: 'number', description: 'Chain depth from root lead session (0 = lead, 1+ = subagent). Used by ADR-147 P3 depth-aware guardrail.' },
         },
         required: ['taskId'],
     },
@@ -1258,6 +1261,22 @@ export const hooksPostTask = {
             if (!v.valid)
                 return { success: false, error: v.error };
         }
+        // ADR-147 P2: validate spawn-tree lineage if provided
+        const parentAgentId = params.parentAgentId;
+        if (parentAgentId !== undefined) {
+            const v = validateIdentifier(parentAgentId, 'parentAgentId');
+            if (!v.valid)
+                return { success: false, error: v.error };
+        }
+        const depthRaw = params.depth;
+        let depth;
+        if (depthRaw !== undefined && depthRaw !== null) {
+            const n = Number(depthRaw);
+            if (!Number.isInteger(n) || n < 0 || n > 32) {
+                return { success: false, error: 'depth must be a non-negative integer ≤ 32' };
+            }
+            depth = n;
+        }
         // Phase 3: Wire recordFeedback through bridge → LearningSystem + ReasoningBank
         let feedbackResult = null;
         try {
@@ -1269,6 +1288,9 @@ export const hooksPostTask = {
                 agent,
                 duration: params.duration || undefined,
                 patterns: params.patterns || undefined,
+                // ADR-147 P2: forward spawn-tree lineage so it lands in feedback + memory
+                parentAgentId,
+                depth,
             });
         }
         catch {

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

@@ -265,6 +265,8 @@ export declare function bridgeRecordFeedback(options: {
     duration?: number;
     patterns?: string[];
     dbPath?: string;
+    parentAgentId?: string;
+    depth?: number;
 }): Promise<{
     success: boolean;
     controller: string;

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

@@ -1422,6 +1422,8 @@ export async function bridgeRecordFeedback(options) {
                     await learningSystem.recordFeedback({
                         taskId: options.taskId, success: options.success, quality: options.quality,
                         agent: options.agent, duration: options.duration, timestamp: Date.now(),
+                        // ADR-147 P2: forward spawn-tree lineage if present
+                        parentAgentId: options.parentAgentId, depth: options.depth,
                     });
                     controller = 'learningSystem';
                     updated++;

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

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