claude-flow 3.7.0-alpha.14 → 3.7.0-alpha.16

package/.claude/settings.local.json

@@ -1 +1,10 @@
-{}
+{
+  "permissions": {
+    "allow": [
+      "Bash(mkdir -p /tmp/ruflo-smoke)",
+      "Bash(rm -rf /tmp/ruflo-smoke/*)",
+      "Read(//tmp/**)",
+      "Bash(npm pack *)"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.14",
+  "version": "3.7.0-alpha.16",
   "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/memory/memory-initializer.d.ts

@@ -8,6 +8,9 @@
  *
  * @module v3/cli/memory-initializer
  */
+export declare function getMemoryRoot(): string;
+/** For tests + the `memory configure` flow that mutates the config at runtime. */
+export declare function _resetMemoryRootCache(): void;
 /**
  * Enhanced schema with pattern confidence, temporal decay, versioning
  * Vector embeddings enabled for semantic search

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

@@ -11,6 +11,61 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { readFileMaybeEncrypted, writeFileRestricted } from '../fs-secure.js';
+/**
+ * #1854: previously every site that needed the memory directory hardcoded
+ * `getMemoryRoot()`, so the documented config entry
+ * points (`memory.persistPath` config field, `memory configure --path`,
+ * `CLAUDE_FLOW_MEMORY_PATH` env var) all silently no-op'd. This helper
+ * is the single source of truth — every `.swarm/memory.db` resolution in
+ * this file flows through it.
+ *
+ * Precedence (highest → lowest):
+ *   1. CLAUDE_FLOW_MEMORY_PATH env var
+ *   2. memory.persistPath / memory.path in claude-flow.config.json (cwd or
+ *      the directory the CLI was invoked from)
+ *   3. Default: cwd/.swarm
+ *
+ * Cached per-process so repeated lookups are cheap; reset only by spawning
+ * a fresh process (which is how config changes already propagate).
+ */
+let _memoryRootCache;
+export function getMemoryRoot() {
+    if (_memoryRootCache !== undefined)
+        return _memoryRootCache;
+    // 1. Env var
+    const envPath = process.env.CLAUDE_FLOW_MEMORY_PATH;
+    if (envPath && envPath.trim().length > 0) {
+        _memoryRootCache = path.resolve(envPath);
+        return _memoryRootCache;
+    }
+    // 2. Config file (claude-flow.config.json)
+    const configCandidates = [
+        path.resolve(process.cwd(), 'claude-flow.config.json'),
+        path.resolve(process.cwd(), '.claude-flow', 'config.json'),
+    ];
+    for (const configPath of configCandidates) {
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            const fromConfig = raw?.memory?.persistPath ?? raw?.memory?.path;
+            if (typeof fromConfig === 'string' && fromConfig.trim().length > 0) {
+                _memoryRootCache = path.resolve(fromConfig);
+                return _memoryRootCache;
+            }
+        }
+        catch {
+            /* malformed config — fall through to default */
+        }
+    }
+    // 3. Default
+    _memoryRootCache = path.resolve(process.cwd(), '.swarm');
+    return _memoryRootCache;
+}
+/** For tests + the `memory configure` flow that mutates the config at runtime. */
+export function _resetMemoryRootCache() {
+    _memoryRootCache = undefined;
+}
 // ADR-053: Lazy import of AgentDB v3 bridge
 let _bridge;
 async function getBridge() {
@@ -358,7 +413,7 @@ export async function getHNSWIndex(options) {
         }
         const { VectorDb } = ruvectorCore;
         // Persistent storage paths — resolve to absolute to survive CWD changes
-        const swarmDir = path.resolve(process.cwd(), '.swarm');
+        const swarmDir = getMemoryRoot();
         if (!fs.existsSync(swarmDir)) {
             fs.mkdirSync(swarmDir, { recursive: true });
         }
@@ -459,7 +514,7 @@ function saveHNSWMetadata() {
     if (!hnswIndex?.entries)
         return;
     try {
-        const swarmDir = path.join(process.cwd(), '.swarm');
+        const swarmDir = getMemoryRoot();
         const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
         const metadata = Array.from(hnswIndex.entries.entries());
         fs.writeFileSync(metadataPath, JSON.stringify(metadata));
@@ -974,7 +1029,7 @@ async function activateControllerRegistry(dbPath, verbose) {
  */
 export async function initializeMemoryDatabase(options) {
     const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
     const dbDir = path.dirname(dbPath);
     try {
@@ -1162,7 +1217,7 @@ export async function initializeMemoryDatabase(options) {
  * Check if memory database is properly initialized
  */
 export async function checkMemoryInitialization(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const path_ = dbPath || path.join(swarmDir, 'memory.db');
     if (!fs.existsSync(path_)) {
         return { initialized: false };
@@ -1211,7 +1266,7 @@ export async function checkMemoryInitialization(dbPath) {
  * Reduces confidence of patterns that haven't been used recently
  */
 export async function applyTemporalDecay(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const path_ = dbPath || path.join(swarmDir, 'memory.db');
     try {
         const initSqlJs = (await import('sql.js')).default;
@@ -1737,7 +1792,7 @@ export async function storeEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
-    const swarmDir = path.resolve(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath ? path.resolve(customPath) : path.join(swarmDir, 'memory.db');
     try {
         if (!fs.existsSync(dbPath)) {
@@ -1830,7 +1885,7 @@ export async function searchEntries(options) {
     // Fallback: raw sql.js
     const { query, namespace, limit = 10, threshold = 0.3, dbPath: customPath } = options;
     const effectiveNamespace = namespace || 'all';
-    const swarmDir = path.resolve(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath ? path.resolve(customPath) : path.join(swarmDir, 'memory.db');
     const startTime = Date.now();
     try {
@@ -2001,7 +2056,7 @@ export async function listEntries(options) {
     }
     // Fallback: raw sql.js
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
     try {
         if (!fs.existsSync(dbPath)) {
@@ -2086,7 +2141,7 @@ export async function getEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
     try {
         if (!fs.existsSync(dbPath)) {
@@ -2190,7 +2245,7 @@ export async function deleteEntry(options) {
     }
     // Fallback: raw sql.js
     const { key, namespace = 'default', dbPath: customPath } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
+    const swarmDir = getMemoryRoot();
     const dbPath = customPath || path.join(swarmDir, 'memory.db');
     try {
         if (!fs.existsSync(dbPath)) {

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

@@ -222,6 +222,12 @@ export declare class HeadlessWorkerExecutor extends EventEmitter {
     /**
      * Get pool status
      */
+    /**
+     * #1855: return the PIDs of all currently-running headless worker
+     * children. Used by `WorkerDaemon` to snapshot active child PIDs to
+     * disk so the next lifetime can reap orphans after a hard crash.
+     */
+    getActiveChildPids(): number[];
     getPoolStatus(): PoolStatus;
     /**
      * Get number of active executions

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

@@ -457,6 +457,20 @@ export class HeadlessWorkerExecutor extends EventEmitter {
     /**
      * Get pool status
      */
+    /**
+     * #1855: return the PIDs of all currently-running headless worker
+     * children. Used by `WorkerDaemon` to snapshot active child PIDs to
+     * disk so the next lifetime can reap orphans after a hard crash.
+     */
+    getActiveChildPids() {
+        const out = [];
+        for (const entry of this.processPool.values()) {
+            const pid = entry.process?.pid;
+            if (typeof pid === 'number' && pid > 0)
+                out.push(pid);
+        }
+        return out;
+    }
     getPoolStatus() {
         const now = Date.now();
         return {
@@ -831,13 +845,33 @@ Analyze the above codebase context and provide your response following the forma
             // Set model
             // Resolve model: user env override > config override > default alias
             env.ANTHROPIC_MODEL = process.env.ANTHROPIC_MODEL || MODEL_IDS[options.model];
-            // Spawn claude CLI process
-            const child = spawn('claude', ['--print', prompt], {
+            // Spawn claude CLI process. #1852: previously the prompt was passed
+            // as a positional CLI arg. On Windows `claude` resolves to
+            // `claude.cmd`, which Node refuses to exec directly (CVE-2024-27980
+            // mitigation) — it routes through `cmd.exe /d /s /c`, which then
+            // re-tokenizes the entire command line including the prompt.
+            // Source-code prompts contain `>` `<` `&` `|` (arrow functions,
+            // comparisons, redirections) — cmd.exe parses those as redirects
+            // and creates zero-byte files in cwd named after the next token
+            // (`controller.abort()`, `{const`, `0`, `HTTP`, etc.).
+            //
+            // Fix: pipe the prompt via stdin instead. `child.stdin.end(prompt)`
+            // 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.
+            const child = spawn('claude', ['--print'], {
                 cwd: this.projectRoot,
                 env,
-                stdio: ['ignore', 'pipe', 'pipe'], // 'ignore' closes stdin at spawn — fixes #1395 where claude --print blocks on EOF
+                stdio: ['pipe', 'pipe', 'pipe'],
                 windowsHide: true, // Prevent phantom console windows on Windows
             });
+            try {
+                child.stdin?.end(prompt);
+            }
+            catch {
+                // stdin already closed (e.g. spawn failed) — `error` handler below
+                // will surface the real cause.
+            }
             // Setup timeout
             const timeoutHandle = setTimeout(() => {
                 if (this.processPool.has(options.executionId)) {

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -106,6 +106,41 @@ export declare class WorkerDaemon extends EventEmitter {
      * Setup graceful shutdown handlers
      */
     private setupShutdownHandlers;
+    /**
+     * #1855: install crash handlers for uncaught exceptions and unhandled
+     * rejections. Without these, a thrown error from any timer callback,
+     * worker logic path, or transitive import crashes the daemon process
+     * silently — the PID file leaks and any in-flight child processes
+     * orphan. With these, we log a structured crash record, run stop()
+     * to clean up, then exit 1 so the process actually dies (otherwise
+     * Node would crash anyway after the handler returns).
+     */
+    private installCrashHandlers;
+    /**
+     * Append a structured crash record to .claude-flow/logs/crash.log.
+     * Inspectable by hand or via `ruflo daemon status` follow-ups.
+     */
+    private writeCrashRecord;
+    /**
+     * Path to the on-disk children registry — list of headless worker
+     * child PIDs the daemon currently owns. #1855: written on every
+     * execution:start / :complete / :error transition; read by the next
+     * lifetime to reap orphans after a hard crash.
+     */
+    private get childrenFile();
+    /**
+     * Snapshot the currently-active headless worker child PIDs to disk.
+     * Best-effort; failures don't propagate.
+     */
+    private writeChildrenSnapshot;
+    /**
+     * #1855: reap orphan headless worker children left behind by a
+     * previous crashed lifetime. Reads `.claude-flow/daemon-children.json`,
+     * SIGTERMs any PID still alive that doesn't belong to the current
+     * daemon, then truncates the file. Called at the top of `start()`
+     * so the next lifetime starts with a clean process tree.
+     */
+    private reapOrphanedChildren;
     /**
      * Check if system resources allow worker execution
      */
@@ -128,6 +163,15 @@ export declare class WorkerDaemon extends EventEmitter {
     /**
      * Check if another daemon instance is already running.
      * Returns the existing PID if alive, or null if no daemon is running.
+     *
+     * #1853: ignore self-PID matches. The detached-spawn path in
+     * `commands/daemon.ts` writes the child's PID into the file as a
+     * fallback after a 500ms wait. If the child reaches `start()` slower
+     * than the parent's 500ms wait (observed on Node 25 / macOS 26), the
+     * child reads its own PID back from the file and concludes "another
+     * daemon is already running" — so it exits before scheduling workers
+     * and `daemon status` reports STOPPED forever. A daemon process is
+     * never "another instance" of itself; treat self-match as absence.
      */
     private checkExistingDaemon;
     /**

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

@@ -79,6 +79,9 @@ export class WorkerDaemon extends EventEmitter {
         };
         // Setup graceful shutdown handlers
         this.setupShutdownHandlers();
+        // #1855: install crash handlers so uncaught exceptions and unhandled
+        // rejections don't leak the PID file or orphan child processes.
+        this.installCrashHandlers();
         // Ensure directories exist
         if (!existsSync(claudeFlowDir)) {
             mkdirSync(claudeFlowDir, { recursive: true });
@@ -104,14 +107,19 @@ export class WorkerDaemon extends EventEmitter {
             this.headlessAvailable = await this.headlessExecutor.isAvailable();
             if (this.headlessAvailable) {
                 this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
+                // Forward headless executor events. #1855: also snapshot the
+                // active child PIDs to disk on every transition so the next
+                // lifetime can reap orphans after a hard crash.
                 this.headlessExecutor.on('execution:start', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:start', data);
                 });
                 this.headlessExecutor.on('execution:complete', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:complete', data);
                 });
                 this.headlessExecutor.on('execution:error', (data) => {
+                    this.writeChildrenSnapshot();
                     this.emit('headless:error', data);
                 });
                 this.headlessExecutor.on('output', (data) => {
@@ -249,6 +257,126 @@ export class WorkerDaemon extends EventEmitter {
         process.on('SIGINT', shutdown);
         process.on('SIGHUP', shutdown);
     }
+    /**
+     * #1855: install crash handlers for uncaught exceptions and unhandled
+     * rejections. Without these, a thrown error from any timer callback,
+     * worker logic path, or transitive import crashes the daemon process
+     * silently — the PID file leaks and any in-flight child processes
+     * orphan. With these, we log a structured crash record, run stop()
+     * to clean up, then exit 1 so the process actually dies (otherwise
+     * Node would crash anyway after the handler returns).
+     */
+    installCrashHandlers() {
+        const onCrash = (kind, err) => {
+            // Best-effort logging; never throw from inside the crash handler.
+            try {
+                this.writeCrashRecord(kind, err);
+            }
+            catch { /* nothing more we can do */ }
+            try {
+                // Synchronous stop — don't await; the process is dying. Just
+                // remove the PID file and snapshot state so the next start
+                // sees a clean slate.
+                this.removePidFile();
+                this.saveState();
+                // Snapshot any in-flight child PIDs one last time so the next
+                // lifetime can reap them.
+                this.writeChildrenSnapshot();
+            }
+            catch { /* ignore */ }
+            // Exit non-zero so supervisors / shells see the failure.
+            process.exit(1);
+        };
+        process.on('uncaughtException', (err) => onCrash('uncaughtException', err));
+        process.on('unhandledRejection', (err) => onCrash('unhandledRejection', err));
+    }
+    /**
+     * Append a structured crash record to .claude-flow/logs/crash.log.
+     * Inspectable by hand or via `ruflo daemon status` follow-ups.
+     */
+    writeCrashRecord(kind, err) {
+        const logDir = this.config.logDir;
+        if (!existsSync(logDir))
+            mkdirSync(logDir, { recursive: true });
+        const crashLog = join(logDir, 'crash.log');
+        const ts = new Date().toISOString();
+        const message = err instanceof Error ? err.message : String(err);
+        const stack = err instanceof Error && err.stack ? err.stack : '<no stack>';
+        const record = `[${ts}] [${kind}] pid=${process.pid} ${message}\n${stack}\n---\n`;
+        appendFileSync(crashLog, record, 'utf-8');
+        this.log('warn', `Daemon crashed (${kind}): ${message} — see ${crashLog}`);
+    }
+    /**
+     * Path to the on-disk children registry — list of headless worker
+     * child PIDs the daemon currently owns. #1855: written on every
+     * execution:start / :complete / :error transition; read by the next
+     * lifetime to reap orphans after a hard crash.
+     */
+    get childrenFile() {
+        return join(this.projectRoot, '.claude-flow', 'daemon-children.json');
+    }
+    /**
+     * Snapshot the currently-active headless worker child PIDs to disk.
+     * Best-effort; failures don't propagate.
+     */
+    writeChildrenSnapshot() {
+        if (!this.headlessExecutor)
+            return;
+        try {
+            const pids = this.headlessExecutor.getActiveChildPids();
+            const dir = join(this.projectRoot, '.claude-flow');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(this.childrenFile, JSON.stringify({ pids, daemonPid: process.pid, timestamp: new Date().toISOString() }, null, 2), 'utf-8');
+        }
+        catch { /* best-effort */ }
+    }
+    /**
+     * #1855: reap orphan headless worker children left behind by a
+     * previous crashed lifetime. Reads `.claude-flow/daemon-children.json`,
+     * SIGTERMs any PID still alive that doesn't belong to the current
+     * daemon, then truncates the file. Called at the top of `start()`
+     * so the next lifetime starts with a clean process tree.
+     */
+    reapOrphanedChildren() {
+        const file = this.childrenFile;
+        if (!existsSync(file))
+            return;
+        let snapshot;
+        try {
+            snapshot = JSON.parse(readFileSync(file, 'utf-8'));
+        }
+        catch {
+            try {
+                unlinkSync(file);
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        const pids = Array.isArray(snapshot.pids) ? snapshot.pids : [];
+        let reaped = 0;
+        for (const pid of pids) {
+            if (typeof pid !== 'number' || pid <= 0)
+                continue;
+            if (pid === process.pid)
+                continue; // never our own PID
+            try {
+                process.kill(pid, 0); // is alive?
+                process.kill(pid, 'SIGTERM');
+                reaped++;
+            }
+            catch {
+                // already dead — fine
+            }
+        }
+        if (reaped > 0) {
+            this.log('info', `Reaped ${reaped} orphan headless worker child(ren) from previous lifetime`);
+        }
+        try {
+            unlinkSync(file);
+        }
+        catch { /* ignore */ }
+    }
     /**
      * Check if system resources allow worker execution
      */
@@ -370,6 +498,15 @@ export class WorkerDaemon extends EventEmitter {
     /**
      * Check if another daemon instance is already running.
      * Returns the existing PID if alive, or null if no daemon is running.
+     *
+     * #1853: ignore self-PID matches. The detached-spawn path in
+     * `commands/daemon.ts` writes the child's PID into the file as a
+     * fallback after a 500ms wait. If the child reaches `start()` slower
+     * than the parent's 500ms wait (observed on Node 25 / macOS 26), the
+     * child reads its own PID back from the file and concludes "another
+     * daemon is already running" — so it exits before scheduling workers
+     * and `daemon status` reports STOPPED forever. A daemon process is
+     * never "another instance" of itself; treat self-match as absence.
      */
     checkExistingDaemon() {
         if (!existsSync(this.pidFile))
@@ -378,6 +515,10 @@ export class WorkerDaemon extends EventEmitter {
             const pid = parseInt(readFileSync(this.pidFile, 'utf-8').trim(), 10);
             if (isNaN(pid))
                 return null;
+            // #1853: a PID file containing our own PID is not "another daemon".
+            // Treat as absent so the start() path proceeds normally.
+            if (pid === process.pid)
+                return null;
             // Check if process is alive (signal 0 = existence check)
             process.kill(pid, 0);
             return pid; // Process is alive
@@ -424,6 +565,11 @@ export class WorkerDaemon extends EventEmitter {
             this.emit('warning', `Daemon already running (PID: ${existingPid})`);
             return;
         }
+        // #1855: reap orphan headless worker children left by a previous
+        // crashed lifetime, BEFORE we mark ourselves running and start
+        // accepting new work. The children file from the prior daemon's
+        // last-snapshot is the authoritative list.
+        this.reapOrphanedChildren();
         this.running = true;
         this.startedAt = new Date();
         this.writePidFile();

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

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