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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.75",
+  "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,14 @@ 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;
     const cwd = ctx.cwd;
@@ -204,6 +211,12 @@ const initAction = async (ctx) => {
     if (onlyClaude) {
         options.components.runtime = false;
     }
+    // ADR-128 Phase 3 — restore full agent set (98 agents) when user explicitly
+    // requests it. Default is the ~24-agent substrate (core, consensus, swarm,
+    // sparc, testing). Pass --all-agents to get the old behavior.
+    if (allAgents) {
+        options.agents.all = true;
+    }
     // #1744 — opt-out of the user-global ~/.claude/CLAUDE.md "Ruflo Integration"
     // pointer block. Default behavior (off) preserves current install for users
     // who rely on it; opting in via --no-global keeps the global file pristine.
@@ -969,6 +982,12 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'all-agents',
+            description: 'Install all agent categories (ADR-128: default is ~24 substrate agents; this restores the full set of ~89)',
+            type: 'boolean',
+            default: false,
+        },
     ],
     examples: [
         { command: 'claude-flow init', description: 'Initialize with default configuration' },
@@ -990,6 +1009,7 @@ export const initCommand = {
         { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
         { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
+        { command: 'claude-flow init --all-agents', description: 'Install all agent categories (~89 agents; ADR-128 opt-in)' },
     ],
     action: initAction,
 };

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

@@ -67,6 +67,10 @@ const SKILLS_MAP = {
 };
 /**
  * Commands to copy based on configuration
+ * ADR-128 Phase 4: every subdirectory under .claude/commands/ now has a
+ * corresponding key. The flow-nexus/ dir was deleted (belongs to the plugin).
+ * New substrate keys default true; opt-in keys (pair, training, stream-chain,
+ * truth, verify) default false per ADR-128 §Phase 3 opt-in rationale.
  */
 const COMMANDS_MAP = {
     core: ['claude-flow-help.md', 'claude-flow-swarm.md', 'claude-flow-memory.md'],
@@ -77,6 +81,19 @@ const COMMANDS_MAP = {
     monitoring: ['monitoring'],
     optimization: ['optimization'],
     sparc: ['sparc'],
+    // ADR-128 Phase 4 promotions (previously orphaned)
+    agents: ['agents'],
+    coordination: ['coordination'],
+    hiveMind: ['hive-mind'],
+    memory: ['memory'],
+    swarm: ['swarm'],
+    workflows: ['workflows'],
+    // Opt-in categories (non-universal; default false in CommandsConfig)
+    pair: ['pair'],
+    training: ['training'],
+    streamChain: ['stream-chain'],
+    truth: ['truth'],
+    verify: ['verify'],
 };
 /**
  * Agents to copy based on configuration
@@ -869,6 +886,30 @@ async function copyCommands(targetDir, options, result) {
             commandsToCopy.push(...COMMANDS_MAP.optimization);
         if (commandsConfig.sparc)
             commandsToCopy.push(...COMMANDS_MAP.sparc);
+        // ADR-128 Phase 4 substrate promotions
+        if (commandsConfig.agents)
+            commandsToCopy.push(...(COMMANDS_MAP.agents || []));
+        if (commandsConfig.coordination)
+            commandsToCopy.push(...(COMMANDS_MAP.coordination || []));
+        if (commandsConfig.hiveMind)
+            commandsToCopy.push(...(COMMANDS_MAP.hiveMind || []));
+        if (commandsConfig.memory)
+            commandsToCopy.push(...(COMMANDS_MAP.memory || []));
+        if (commandsConfig.swarm)
+            commandsToCopy.push(...(COMMANDS_MAP.swarm || []));
+        if (commandsConfig.workflows)
+            commandsToCopy.push(...(COMMANDS_MAP.workflows || []));
+        // ADR-128 Phase 4 opt-in categories
+        if (commandsConfig.pair)
+            commandsToCopy.push(...(COMMANDS_MAP.pair || []));
+        if (commandsConfig.training)
+            commandsToCopy.push(...(COMMANDS_MAP.training || []));
+        if (commandsConfig.streamChain)
+            commandsToCopy.push(...(COMMANDS_MAP.streamChain || []));
+        if (commandsConfig.truth)
+            commandsToCopy.push(...(COMMANDS_MAP.truth || []));
+        if (commandsConfig.verify)
+            commandsToCopy.push(...(COMMANDS_MAP.verify || []));
     }
     // Find source commands directory
     const sourceCommandsDir = findSourceDir('commands', options.sourceBaseDir);

package/v3/@claude-flow/cli/dist/src/init/types.d.ts

@@ -81,6 +81,7 @@ export interface SkillsConfig {
 }
 /**
  * Commands configuration
+ * ADR-128 Phase 4: new keys for promoted substrate dirs and opt-in categories.
  */
 export interface CommandsConfig {
     /** Include core commands */
@@ -99,6 +100,28 @@ export interface CommandsConfig {
     optimization: boolean;
     /** Include SPARC commands */
     sparc: boolean;
+    /** Include agents commands */
+    agents?: boolean;
+    /** Include coordination commands */
+    coordination?: boolean;
+    /** Include hive-mind commands */
+    hiveMind?: boolean;
+    /** Include memory commands */
+    memory?: boolean;
+    /** Include swarm commands */
+    swarm?: boolean;
+    /** Include workflows commands */
+    workflows?: boolean;
+    /** Include pair programming commands (opt-in) */
+    pair?: boolean;
+    /** Include training commands (opt-in) */
+    training?: boolean;
+    /** Include stream-chain commands (opt-in) */
+    streamChain?: boolean;
+    /** Include truth commands (opt-in) */
+    truth?: boolean;
+    /** Include verify commands (opt-in) */
+    verify?: boolean;
     /** Include all commands */
     all: boolean;
 }

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

@@ -89,21 +89,34 @@ export const DEFAULT_INIT_OPTIONS = {
         monitoring: true,
         optimization: true,
         sparc: true,
+        // ADR-128 Phase 4 substrate promotions (default true — core swarm substrate)
+        agents: true,
+        coordination: true,
+        hiveMind: true,
+        memory: true,
+        swarm: true,
+        workflows: true,
+        // ADR-128 Phase 4 opt-in (default false — not universal)
+        pair: false,
+        training: false,
+        streamChain: false,
+        truth: false,
+        verify: false,
         all: false,
     },
     agents: {
         core: true,
         consensus: true,
-        github: true,
-        hiveMind: true,
+        github: false, // ADR-128 Phase 3: opt-in via --agents=github or --all-agents
+        hiveMind: false, // ADR-128 Phase 3: opt-in via --all-agents
         sparc: true,
         swarm: true,
         browser: true,
-        v3: true,
-        optimization: true,
+        v3: false, // ADR-128 Phase 3: opt-in via --agents=v3 or --all-agents
+        optimization: false, // ADR-128 Phase 3: opt-in via --all-agents
         testing: true,
         dualMode: false, // Optional: enable with --dual flag
-        all: true,
+        all: false, // ADR-128 Phase 3: was true; use --all-agents to restore
     },
     statusline: {
         enabled: true,

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.75",
+  "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",