claude-flow 3.7.0-alpha.76 → 3.7.0-alpha.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.76",
+  "version": "3.7.0-alpha.77",
   "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/init.js

@@ -145,7 +145,13 @@ const initAction = async (ctx) => {
     const full = ctx.flags.full;
     const skipClaude = ctx.flags['skip-claude'];
     const onlyClaude = ctx.flags['only-claude'];
-    const noGlobal = ctx.flags['no-global'];
+    // #2098A — the parser handles `--no-foo` by stripping the prefix and
+    // storing `flags.foo = false` (parser.ts:291-294), not by storing
+    // `flags['no-foo'] = true`. So `--no-global` lands as
+    // `ctx.flags.global === false`. The old read of `flags['no-global']`
+    // was always undefined and silently no-op'd — every user with the flag
+    // set still got `~/.claude/CLAUDE.md` modified. Read the real key.
+    const noGlobal = ctx.flags['no-global'] === true || ctx.flags['global'] === false;
     const allAgents = ctx.flags['all-agents'];
     const codexMode = ctx.flags.codex;
     const dualMode = ctx.flags.dual;

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

@@ -174,6 +174,10 @@ export const agentTools = [
             properties: {
                 agentType: { type: 'string', description: 'Type of agent to spawn' },
                 agentId: { type: 'string', description: 'Optional custom agent ID' },
+                // #2085 — accept swarmId so spawned agents register in the
+                // swarm.agents array that swarm_status reports. Omit to register
+                // with the most-recently-created swarm.
+                swarmId: { type: 'string', description: 'Optional swarm to register the agent with (defaults to most-recent swarm)' },
                 config: { type: 'object', description: 'Agent configuration' },
                 domain: { type: 'string', description: 'Agent domain' },
                 model: {
@@ -217,6 +221,33 @@ export const agentTools = [
             };
             store.agents[agentId] = agent;
             saveAgentStore(store);
+            // #2085 — also push to the swarm store's agents array so that
+            // swarm_status reports the new agent. Without this, agent_spawn
+            // and swarm_status read/write separate stores and agents added
+            // post-init never show up in swarm_status.agents — confirmed for
+            // all topologies (hierarchical, mesh, etc.).
+            try {
+                const { loadSwarmStore: _loadSwarmStore, saveSwarmStore: _saveSwarmStore } = await import('./swarm-tools.js');
+                const swarmStore = _loadSwarmStore();
+                let targetSwarmId = input.swarmId || '';
+                if (!targetSwarmId) {
+                    // Default to the most-recently-created swarm.
+                    const all = Object.values(swarmStore.swarms);
+                    const latest = all.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+                    targetSwarmId = latest?.swarmId || '';
+                }
+                if (targetSwarmId && swarmStore.swarms[targetSwarmId]) {
+                    const swarm = swarmStore.swarms[targetSwarmId];
+                    if (!Array.isArray(swarm.agents))
+                        swarm.agents = [];
+                    // Idempotent — don't duplicate if agent_spawn is retried.
+                    if (!swarm.agents.includes(agentId)) {
+                        swarm.agents.push(agentId);
+                        _saveSwarmStore(swarmStore);
+                    }
+                }
+            }
+            catch { /* swarm store unavailable — agent still registered globally */ }
             // Record agent in graph database (ADR-087, best-effort)
             try {
                 const { addNode } = await import('../ruvector/graph-backend.js');

package/v3/@claude-flow/cli/dist/src/mcp-tools/swarm-tools.d.ts

@@ -5,5 +5,33 @@
  * Replaces previous stub implementations with real state tracking.
  */
 import { type MCPTool } from './types.js';
+interface SwarmState {
+    swarmId: string;
+    topology: string;
+    maxAgents: number;
+    status: 'initializing' | 'running' | 'paused' | 'shutting_down' | 'terminated';
+    agents: string[];
+    tasks: string[];
+    config: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * #1799 — process that initialized this swarm. Used by reconciliation
+     * on `loadSwarmStore()` to detect orphan entries whose host process has
+     * already exited (common on Windows where backgrounded daemons don't
+     * always survive shell exit). Optional for backward compat with
+     * pre-#1799 stores.
+     */
+    pid?: number;
+    /** Reason set when status was forced to 'terminated' by reconciliation. */
+    terminationReason?: string;
+}
+interface SwarmStore {
+    swarms: Record<string, SwarmState>;
+    version: string;
+}
+export declare function loadSwarmStore(): SwarmStore;
+export declare function saveSwarmStore(store: SwarmStore): void;
 export declare const swarmTools: MCPTool[];
+export {};
 //# sourceMappingURL=swarm-tools.d.ts.map

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

@@ -78,7 +78,9 @@ function reconcileOrphanSwarms(store) {
     }
     return reconciled;
 }
-function loadSwarmStore() {
+// #2085 — exported so `agent-tools.ts agent_spawn` can push into
+// `swarm.agents` (the field `swarm_status` reads).
+export function loadSwarmStore() {
     let store = { swarms: {}, version: '3.0.0' };
     try {
         const path = getSwarmStatePath();
@@ -99,7 +101,7 @@ function loadSwarmStore() {
     }
     return store;
 }
-function saveSwarmStore(store) {
+export function saveSwarmStore(store) {
     ensureSwarmDir();
     writeFileSync(getSwarmStatePath(), JSON.stringify(store, null, 2), 'utf-8');
 }

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

@@ -859,11 +859,19 @@ Analyze the above codebase context and provide your response following the forma
             // writes the prompt and closes stdin atomically — the EOF still
             // unblocks `claude --print` (the original concern in #1395) but no
             // shell tokenization touches the prompt.
+            // #2098B / #2093 — `claude --print` can spawn grandchildren (MCP
+            // server stdio bridges, plugin tools). When the head times out a
+            // plain `child.kill()` only signals the head; grandchildren get
+            // reparented to init and survive — the symptom @maxstefanakis1114
+            // diagnosed as a 5-second redispatch + subprocess-table growth.
+            // `detached: true` puts the child in its own process group so we
+            // can signal the whole tree with `process.kill(-pid, sig)`.
             const child = spawn('claude', ['--print'], {
                 cwd: this.projectRoot,
                 env,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 windowsHide: true, // Prevent phantom console windows on Windows
+                detached: process.platform !== 'win32',
             });
             try {
                 child.stdin?.end(prompt);
@@ -872,14 +880,29 @@ Analyze the above codebase context and provide your response following the forma
                 // stdin already closed (e.g. spawn failed) — `error` handler below
                 // will surface the real cause.
             }
+            // Kill the whole process group on POSIX, fall back to the child on
+            // Windows (where setsid-style detach isn't available the same way).
+            const killTree = (signal) => {
+                if (process.platform !== 'win32' && typeof child.pid === 'number') {
+                    try {
+                        process.kill(-child.pid, signal);
+                        return;
+                    }
+                    catch { /* fall through */ }
+                }
+                try {
+                    child.kill(signal);
+                }
+                catch { /* already dead */ }
+            };
             // Setup timeout
             const timeoutHandle = setTimeout(() => {
                 if (this.processPool.has(options.executionId)) {
-                    child.kill('SIGTERM');
+                    killTree('SIGTERM');
                     // Give it a moment to terminate gracefully
                     setTimeout(() => {
                         if (!child.killed) {
-                            child.kill('SIGKILL');
+                            killTree('SIGKILL');
                         }
                     }, 5000);
                 }
@@ -947,7 +970,7 @@ Analyze the above codebase context and provide your response following the forma
                 if (!this.processPool.has(options.executionId))
                     return;
                 resolved = true;
-                child.kill('SIGTERM');
+                killTree('SIGTERM');
                 cleanup();
                 resolve({
                     success: false,

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.76",
+  "version": "3.7.0-alpha.77",
   "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",