claude-flow 3.10.42 → 3.10.44

package/README.md

@@ -16,10 +16,6 @@
 [![Codex Plugin](https://img.shields.io/badge/Codex-Plugin-412991?style=for-the-badge&logoColor=white&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI%2BPHBhdGggZmlsbD0id2hpdGUiIGQ9Ik0yMi4yODIgOS44MjFhNS45ODUgNS45ODUgMCAwIDAtLjUxNi00LjkxIDYuMDQ2IDYuMDQ2IDAgMCAwLTYuNTEtMi45QTYuMDY1IDYuMDY1IDAgMCAwIDQuOTgxIDQuMThhNS45ODUgNS45ODUgMCAwIDAtMy45OTggMi45IDYuMDQ2IDYuMDQ2IDAgMCAwIC43NDMgNy4wOTcgNS45OCA1Ljk4IDAgMCAwIC41MSA0LjkxMSA2LjA1MSA2LjA1MSAwIDAgMCA2LjUxNSAyLjlBNS45ODUgNS45ODUgMCAwIDAgMTMuMjYgMjRhNi4wNTYgNi4wNTYgMCAwIDAgNS43NzItNC4yMDYgNS45OSA1Ljk5IDAgMCAwIDMuOTk4LTIuOSA2LjA1NiA2LjA1NiAwIDAgMC0uNzQ3LTcuMDczek0xMy4yNiAyMi40M2E0LjQ3NiA0LjQ3NiAwIDAgMS0yLjg3Ni0xLjA0bC4xNDItLjA4IDQuNzc4LTIuNzU4YS43OTUuNzk1IDAgMCAwIC4zOTMtLjY4MXYtNi43MzdsMi4wMiAxLjE2OGEuMDcxLjA3MSAwIDAgMSAuMDM4LjA1MnY1LjU4M2E0LjUwNCA0LjUwNCAwIDAgMS00LjQ5NSA0LjQ5NHpNMy42IDE4LjMwNGE0LjQ3IDQuNDcgMCAwIDEtLjUzNS0zLjAxNGwuMTQyLjA4NSA0Ljc4MyAyLjc1OWEuNzcxLjc3MSAwIDAgMCAuNzgxIDBsNS44NDMtMy4zNjl2Mi4zMzJhLjA4LjA4IDAgMCAxLS4wMzMuMDYyTDkuNzQgMTkuOTVhNC41IDQuNSAwIDAgMS02LjE0LTEuNjQ2ek0yLjM0IDcuODk2YTQuNDg1IDQuNDg1IDAgMCAxIDIuMzY2LTEuOTczVjExLjZhLjc2Ni43NjYgMCAwIDAgLjM4OC42NzdsNS44MTUgMy4zNTQtMi4wMiAxLjE2OGEuMDc2LjA3NiAwIDAgMS0uMDcyIDBsLTQuODMtMi43ODZBNC41MDQgNC41MDQgMCAwIDEgMi4zNCA3Ljg3MnptMTYuNTk3IDMuODU1LTUuODMzLTMuMzg3IDIuMDE2LTEuMTY1YS4wNzYuMDc2IDAgMCAxIC4wNzEgMGw0LjgzIDIuNzkxYTQuNDk0IDQuNDk0IDAgMCAxLS42NzYgOC4xMDR2LTUuNjc3YS43OS43OSAwIDAgMC0uNDA3LS42Njd6bTIuMDEtMy4wMjMtLjE0MS0uMDg1LTQuNzc0LTIuNzgyYS43NzYuNzc2IDAgMCAwLS43ODUgMEw5LjQwOSA5LjIzVjYuODk3YS4wNjYuMDY2IDAgMCAxIC4wMjgtLjA2Mmw0LjgzLTIuNzg3YTQuNDk5IDQuNDk5IDAgMCAxIDYuNjggNC42NnpNOC4zMDcgMTIuODYzbC0yLjAyLTEuMTY0YS4wOC4wOCAwIDAgMS0uMDM4LS4wNTdWNi4wNzRhNC40OTkgNC40OTkgMCAwIDEgNy4zNzYtMy40NTRsLS4xNDIuMDgtNC43NzggMi43NThhLjc5NS43OTUgMCAwIDAtLjM5My42ODJ6bTEuMDk3LTIuMzY2IDIuNjAyLTEuNSAyLjYwNyAxLjV2Mi45OTlsLTIuNTk3IDEuNS0yLjYwNy0xLjVaIi8%2BPC9zdmc%2B)](https://www.npmjs.com/package/@claude-flow/codex)
 [![🕸️ RuVector Graph Ai](https://img.shields.io/badge/RuVector_Agentic-DB-06b6d4?style=for-the-badge&logoColor=white&logo=graphql)](https://github.com/ruvnet/ruvector)
 
-[![RuFlo Agentic Appliance](v3/docs/assets/RuFlo-agentic-appliance.png)](https://cognitum.one/appliance)
-
-[![ruFlo Summit — Budapest, June 2–3, 2026](v3/docs/assets/ruFlo-Summit.jpg)](https://github.com/ruvnet/ruflo/issues/1967)
-
 # Ruflo
 
 **Multi-agent AI harness for Claude Code and Codex**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.10.42",
+  "version": "3.10.44",
   "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/README.md

@@ -16,10 +16,6 @@
 [![Codex Plugin](https://img.shields.io/badge/Codex-Plugin-412991?style=for-the-badge&logoColor=white&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCI%2BPHBhdGggZmlsbD0id2hpdGUiIGQ9Ik0yMi4yODIgOS44MjFhNS45ODUgNS45ODUgMCAwIDAtLjUxNi00LjkxIDYuMDQ2IDYuMDQ2IDAgMCAwLTYuNTEtMi45QTYuMDY1IDYuMDY1IDAgMCAwIDQuOTgxIDQuMThhNS45ODUgNS45ODUgMCAwIDAtMy45OTggMi45IDYuMDQ2IDYuMDQ2IDAgMCAwIC43NDMgNy4wOTcgNS45OCA1Ljk4IDAgMCAwIC41MSA0LjkxMSA2LjA1MSA2LjA1MSAwIDAgMCA2LjUxNSAyLjlBNS45ODUgNS45ODUgMCAwIDAgMTMuMjYgMjRhNi4wNTYgNi4wNTYgMCAwIDAgNS43NzItNC4yMDYgNS45OSA1Ljk5IDAgMCAwIDMuOTk4LTIuOSA2LjA1NiA2LjA1NiAwIDAgMC0uNzQ3LTcuMDczek0xMy4yNiAyMi40M2E0LjQ3NiA0LjQ3NiAwIDAgMS0yLjg3Ni0xLjA0bC4xNDItLjA4IDQuNzc4LTIuNzU4YS43OTUuNzk1IDAgMCAwIC4zOTMtLjY4MXYtNi43MzdsMi4wMiAxLjE2OGEuMDcxLjA3MSAwIDAgMSAuMDM4LjA1MnY1LjU4M2E0LjUwNCA0LjUwNCAwIDAgMS00LjQ5NSA0LjQ5NHpNMy42IDE4LjMwNGE0LjQ3IDQuNDcgMCAwIDEtLjUzNS0zLjAxNGwuMTQyLjA4NSA0Ljc4MyAyLjc1OWEuNzcxLjc3MSAwIDAgMCAuNzgxIDBsNS44NDMtMy4zNjl2Mi4zMzJhLjA4LjA4IDAgMCAxLS4wMzMuMDYyTDkuNzQgMTkuOTVhNC41IDQuNSAwIDAgMS02LjE0LTEuNjQ2ek0yLjM0IDcuODk2YTQuNDg1IDQuNDg1IDAgMCAxIDIuMzY2LTEuOTczVjExLjZhLjc2Ni43NjYgMCAwIDAgLjM4OC42NzdsNS44MTUgMy4zNTQtMi4wMiAxLjE2OGEuMDc2LjA3NiAwIDAgMS0uMDcyIDBsLTQuODMtMi43ODZBNC41MDQgNC41MDQgMCAwIDEgMi4zNCA3Ljg3MnptMTYuNTk3IDMuODU1LTUuODMzLTMuMzg3IDIuMDE2LTEuMTY1YS4wNzYuMDc2IDAgMCAxIC4wNzEgMGw0LjgzIDIuNzkxYTQuNDk0IDQuNDk0IDAgMCAxLS42NzYgOC4xMDR2LTUuNjc3YS43OS43OSAwIDAgMC0uNDA3LS42Njd6bTIuMDEtMy4wMjMtLjE0MS0uMDg1LTQuNzc0LTIuNzgyYS43NzYuNzc2IDAgMCAwLS43ODUgMEw5LjQwOSA5LjIzVjYuODk3YS4wNjYuMDY2IDAgMCAxIC4wMjgtLjA2Mmw0LjgzLTIuNzg3YTQuNDk5IDQuNDk5IDAgMCAxIDYuNjggNC42NnpNOC4zMDcgMTIuODYzbC0yLjAyLTEuMTY0YS4wOC4wOCAwIDAgMS0uMDM4LS4wNTdWNi4wNzRhNC40OTkgNC40OTkgMCAwIDEgNy4zNzYtMy40NTRsLS4xNDIuMDgtNC43NzggMi43NThhLjc5NS43OTUgMCAwIDAtLjM5My42ODJ6bTEuMDk3LTIuMzY2IDIuNjAyLTEuNSAyLjYwNyAxLjV2Mi45OTlsLTIuNTk3IDEuNS0yLjYwNy0xLjVaIi8%2BPC9zdmc%2B)](https://www.npmjs.com/package/@claude-flow/codex)
 [![🕸️ RuVector Graph Ai](https://img.shields.io/badge/RuVector_Agentic-DB-06b6d4?style=for-the-badge&logoColor=white&logo=graphql)](https://github.com/ruvnet/ruvector)
 
-[![RuFlo Agentic Appliance](v3/docs/assets/RuFlo-agentic-appliance.png)](https://cognitum.one/appliance)
-
-[![ruFlo Summit — Budapest, June 2–3, 2026](v3/docs/assets/ruFlo-Summit.jpg)](https://github.com/ruvnet/ruflo/issues/1967)
-
 # Ruflo
 
 **Multi-agent AI harness for Claude Code and Codex**

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

@@ -23,6 +23,14 @@ export declare function resolveWorkspaceFlag(raw: unknown): string | null;
  * via the PID file.
  */
 export declare function daemonCommandLineBelongsToWorkspace(commandLine: string, workspaceRoot: string): boolean;
+/**
+ * #2356: extract the workspace root from a daemon process command line for the
+ * global `daemon status --all` view. The launcher always appends
+ * `--workspace <root>` as the FINAL argv entry (see startBackgroundDaemon), so
+ * we capture everything after it to end-of-line and strip trailing quotes.
+ * Returns null for pre-#1914 daemons that never stamped a workspace.
+ */
+export declare function extractWorkspaceFromDaemonLine(commandLine: string): string | null;
 export declare const daemonCommand: Command;
 export default daemonCommand;
 //# sourceMappingURL=daemon.d.ts.map

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

@@ -21,6 +21,9 @@ const startCommand = {
         { name: 'sandbox', type: 'string', description: 'Default sandbox mode for headless workers', choices: ['strict', 'permissive', 'disabled'] },
         { name: 'max-cpu-load', type: 'string', description: 'Override maxCpuLoad resource threshold (e.g. 4.0)' },
         { name: 'min-free-memory', type: 'string', description: 'Override minFreeMemoryPercent resource threshold (e.g. 15)' },
+        // #2356: self-terminating lifecycle. Caps how long a forgotten daemon can
+        // keep dispatching headless worker sweeps. Default 12h (or RUFLO_DAEMON_TTL_SECS); 0 = run until stopped.
+        { name: 'ttl', type: 'string', description: 'Max daemon age in seconds before graceful self-shutdown (0 = run until stopped; default 43200 = 12h)' },
         // #1914: workspace root for this daemon. Set automatically when the
         // background launcher forks the foreground child so the daemon process
         // carries its workspace path in argv — `killStaleDaemons` then only
@@ -71,6 +74,18 @@ const startCommand = {
                 config.resourceThresholds = thresholds;
             }
         }
+        // #2356: parse --ttl (seconds → ms). Integer-only so 0 (disable) is valid;
+        // INT_RE forbids the decimals NUMERIC_RE allows, since a TTL is whole seconds.
+        const rawTtl = ctx.flags.ttl;
+        const INT_RE = /^\d+$/;
+        if (rawTtl !== undefined) {
+            if (INT_RE.test(rawTtl)) {
+                config.ttlMs = parseInt(rawTtl, 10) * 1000;
+            }
+            else if (!quiet) {
+                output.printWarning(`Ignoring invalid --ttl value: ${sanitize(rawTtl)}`);
+            }
+        }
         // Check if background daemon already running (skip if we ARE the daemon process)
         if (!isDaemonProcess) {
             const bgPid = getBackgroundDaemonPid(projectRoot);
@@ -95,6 +110,7 @@ const startCommand = {
                 workers: ctx.flags.workers,
                 headless: ctx.flags.headless,
                 sandbox: ctx.flags.sandbox,
+                ttl: rawTtl,
             });
         }
         // Foreground mode: run in current process (blocks terminal)
@@ -134,6 +150,9 @@ const startCommand = {
                 output.printBox([
                     `PID: ${status.pid}`,
                     `Started: ${status.startedAt?.toISOString()}`,
+                    status.config.ttlMs > 0
+                        ? `TTL: ${Math.round(status.config.ttlMs / 3600000)}h (self-shutdown)`
+                        : `TTL: off (runs until stopped)`,
                     `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
                     `Max Concurrent: ${status.config.maxConcurrent}`,
                     `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
@@ -243,8 +262,22 @@ export function resolveWorkspaceFlag(raw) {
 export function daemonCommandLineBelongsToWorkspace(commandLine, workspaceRoot) {
     return commandLine.replace(/[\s"']+$/u, '').endsWith(`--workspace ${workspaceRoot}`);
 }
+/**
+ * #2356: extract the workspace root from a daemon process command line for the
+ * global `daemon status --all` view. The launcher always appends
+ * `--workspace <root>` as the FINAL argv entry (see startBackgroundDaemon), so
+ * we capture everything after it to end-of-line and strip trailing quotes.
+ * Returns null for pre-#1914 daemons that never stamped a workspace.
+ */
+export function extractWorkspaceFromDaemonLine(commandLine) {
+    const m = commandLine.match(/--workspace\s+(.+?)\s*$/u);
+    if (!m)
+        return null;
+    const ws = m[1].replace(/["']+$/u, '').trim();
+    return ws.length > 0 ? ws : null;
+}
 async function startBackgroundDaemon(projectRoot, quiet, forwarded = {}) {
-    const { maxCpuLoad, minFreeMemory, workers, headless, sandbox } = forwarded;
+    const { maxCpuLoad, minFreeMemory, workers, headless, sandbox, ttl } = forwarded;
     // Validate and resolve project root
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
@@ -312,6 +345,11 @@ async function startBackgroundDaemon(projectRoot, quiet, forwarded = {}) {
     if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
         forkArgs.push('--min-free-memory', minFreeMemory);
     }
+    // #2356: forward the TTL so the background daemon enforces it too. Integer
+    // seconds only (incl. 0 to disable) — reject anything else before it hits argv.
+    if (typeof ttl === 'string' && /^\d+$/.test(ttl)) {
+        forkArgs.push('--ttl', ttl);
+    }
     // #1968: forward worker-selection / sandbox flags. The previous launcher
     // dropped these, so `daemon start --workers map` ran with the default
     // five-worker set instead of just `map`. Validate each before passing
@@ -599,6 +637,116 @@ function isProcessRunning(pid) {
         return false;
     }
 }
+/**
+ * #2356: enumerate every running ruflo daemon across ALL workspaces. Reuses
+ * the same `ps`/`tasklist` scan as killStaleDaemons but, instead of killing,
+ * returns each live daemon's PID + workspace so `daemon status --all` can
+ * surface daemons leaked in other projects. Best-effort: any tooling failure
+ * yields an empty list (matching the kill-stale paths).
+ */
+async function scanRunningDaemons() {
+    const isWin = process.platform === 'win32';
+    try {
+        const { execFileSync } = await import('child_process');
+        const out = isWin
+            ? execFileSync('tasklist', ['/v', '/fo', 'csv', '/nh'], { encoding: 'utf-8', timeout: 5000 })
+            : execFileSync('ps', ['-eo', 'pid,command'], { encoding: 'utf-8', timeout: 5000 });
+        const lines = out.split(/\r?\n/);
+        const found = [];
+        for (const line of lines) {
+            if (!line.includes('daemon start --foreground'))
+                continue;
+            if (!line.includes('claude-flow') && !line.includes('@claude-flow/cli'))
+                continue;
+            let pid;
+            let cmd;
+            if (isWin) {
+                // tasklist /fo csv: quoted fields; PID is field[1], Window Title is last.
+                const fields = line.split(/","/).map(f => f.replace(/^"|"$/g, ''));
+                pid = parseInt(fields[1] ?? '', 10);
+                cmd = fields[fields.length - 1] ?? line;
+            }
+            else {
+                pid = parseInt(line.trim().split(/\s+/)[0], 10);
+                cmd = line;
+            }
+            if (Number.isNaN(pid) || !isProcessRunning(pid))
+                continue;
+            found.push({ pid, workspace: extractWorkspaceFromDaemonLine(cmd) });
+        }
+        return found;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * #2356: render the global `daemon status --all` view. For each running daemon
+ * it reads that workspace's daemon-state.json to show age + configured TTL,
+ * and flags any daemon that has outlived its TTL (or 12h when TTL is unknown)
+ * as stale — the visibility that was missing when leaked daemons ran for days.
+ */
+async function renderAllDaemonsStatus() {
+    const daemons = await scanRunningDaemons();
+    output.writeln();
+    if (daemons.length === 0) {
+        output.printBox('No ruflo daemons are running in any workspace.', 'RuFlo Daemons (all workspaces)');
+        return { success: true, data: { daemons: [] } };
+    }
+    const now = Date.now();
+    const TWELVE_HOURS_MS = 12 * 60 * 60 * 1000;
+    let staleCount = 0;
+    const rows = daemons.map(d => {
+        let startedAt;
+        let ttlMs;
+        if (d.workspace) {
+            try {
+                const statePath = join(d.workspace, '.claude-flow', 'daemon-state.json');
+                if (fs.existsSync(statePath)) {
+                    const st = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                    if (st?.startedAt)
+                        startedAt = new Date(st.startedAt);
+                    if (typeof st?.config?.ttlMs === 'number')
+                        ttlMs = st.config.ttlMs;
+                }
+            }
+            catch { /* unreadable/partial state — show what we have */ }
+        }
+        const ageMs = startedAt ? now - startedAt.getTime() : undefined;
+        const overTtl = ttlMs !== undefined && ttlMs > 0 && ageMs !== undefined && ageMs > ttlMs;
+        const overTwelveH = ageMs !== undefined && ageMs > TWELVE_HOURS_MS;
+        const isStale = overTtl || overTwelveH;
+        if (isStale)
+            staleCount++;
+        const ageText = ageMs !== undefined ? formatTimeAgo(startedAt).replace(' ago', '') : '?';
+        const ttlText = ttlMs !== undefined
+            ? (ttlMs > 0 ? `${Math.round(ttlMs / 3600000)}h` : 'off')
+            : '?';
+        return {
+            pid: isStale ? output.warning(String(d.pid)) : String(d.pid),
+            workspace: d.workspace ?? output.dim('(unknown)'),
+            age: isStale ? output.warning(ageText) : ageText,
+            ttl: ttlText === 'off' ? output.dim('off') : ttlText,
+        };
+    });
+    output.printTable({
+        columns: [
+            { key: 'pid', header: 'PID', width: 8 },
+            { key: 'age', header: 'Age', width: 8 },
+            { key: 'ttl', header: 'TTL', width: 6 },
+            { key: 'workspace', header: 'Workspace', width: 50 },
+        ],
+        data: rows,
+    });
+    output.writeln();
+    if (staleCount > 0) {
+        output.printWarning(`${staleCount} daemon(s) have outlived their TTL (or have run >12h). Stop one with: cd <workspace> && ruflo daemon stop`);
+    }
+    else {
+        output.printInfo(`${daemons.length} daemon(s) running, all within their TTL.`);
+    }
+    return { success: true, data: { daemons: rows.length } };
+}
 // Status subcommand
 const statusCommand = {
     name: 'status',
@@ -606,15 +754,24 @@ const statusCommand = {
     options: [
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed worker statistics' },
         { name: 'show-modes', type: 'boolean', description: 'Show worker execution modes (local/headless) and sandbox settings' },
+        // #2356: the default status reads only the CURRENT workspace, so a daemon
+        // leaked in another project is invisible. --all scans every running ruflo
+        // daemon across all workspaces (the global view that surfaces leaks).
+        { name: 'all', short: 'a', type: 'boolean', description: 'List ruflo daemons across ALL workspaces (global view — surfaces leaked daemons)' },
     ],
     examples: [
         { command: 'claude-flow daemon status', description: 'Show daemon status' },
         { command: 'claude-flow daemon status -v', description: 'Show detailed status' },
         { command: 'claude-flow daemon status --show-modes', description: 'Show worker execution modes' },
+        { command: 'claude-flow daemon status --all', description: 'List daemons across all workspaces' },
     ],
     action: async (ctx) => {
         const verbose = ctx.flags.verbose;
         const showModes = ctx.flags['show-modes'];
+        // #2356: global view across every workspace, not just cwd.
+        if (ctx.flags.all) {
+            return renderAllDaemonsStatus();
+        }
         const projectRoot = process.cwd();
         try {
             const daemon = getDaemon(projectRoot);
@@ -633,6 +790,9 @@ const statusCommand = {
                 `Status: ${statusIcon} ${statusText}${mode}`,
                 `PID: ${displayPid}`,
                 status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
+                status.config.ttlMs > 0
+                    ? `TTL: ${Math.round(status.config.ttlMs / 3600000)}h (self-shutdown)`
+                    : `TTL: ${output.dim('off (runs until stopped)')}`,
                 `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
                 `Max Concurrent: ${status.config.maxConcurrent}`,
                 `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,

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

@@ -190,6 +190,7 @@ const initAction = async (ctx) => {
     // 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 cloudMcp = ctx.flags['cloud-mcp'];
     const codexMode = ctx.flags.codex;
     const dualMode = ctx.flags.dual;
     const cwd = ctx.cwd;
@@ -230,6 +231,12 @@ const initAction = async (ctx) => {
     }
     else if (full) {
         options = { ...FULL_INIT_OPTIONS, targetDir: cwd, force };
+        // #2356: keep auth-gated cloud MCP servers opt-in even under --full. They
+        // require a login, get committed into .mcp.json, and add per-session MCP
+        // tool-definition token cost. --cloud-mcp restores the all-three behavior.
+        if (!cloudMcp) {
+            options.mcp = { ...options.mcp, ruvSwarm: false, flowNexus: false };
+        }
     }
     else {
         options = { ...DEFAULT_INIT_OPTIONS, targetDir: cwd, force };
@@ -970,6 +977,16 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            // #2356: under --full, the auth-gated cloud MCP servers (ruv-swarm,
+            // flow-nexus) get written into a committed .mcp.json and add MCP
+            // tool-definition token cost every session. Keep them opt-in even with
+            // --full; pass --cloud-mcp to register them.
+            name: 'cloud-mcp',
+            description: 'Register auth-gated cloud MCP servers (ruv-swarm, flow-nexus) in .mcp.json (only relevant with --full)',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'skip-claude',
             description: 'Skip .claude/ directory creation (runtime only)',

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

@@ -411,11 +411,21 @@ const statusCommand = {
                         details: `${stats.patternsLearned} patterns stored`,
                     },
                     {
+                        // #2356: distinguish "loaded in this process" from "installed but
+                        // not yet loaded" from "not installed". Previously `neural status`
+                        // always printed "Not loaded" because it never warms the lazy
+                        // singleton — a false negative even when @ruvector/core is present.
                         component: 'HNSW Index',
-                        status: hnswStatus.available ? output.success('Ready') : output.dim('Not loaded'),
-                        details: hnswStatus.available
+                        status: hnswStatus.initialized
+                            ? output.success('Ready')
+                            : hnswStatus.available
+                                ? output.info('Available')
+                                : output.dim('Not installed'),
+                        details: hnswStatus.initialized
                             ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim`
-                            : '@ruvector/core not available',
+                            : hnswStatus.available
+                                ? '@ruvector/core installed (loads on first vector search)'
+                                : '@ruvector/core not available',
                     },
                     {
                         component: 'Embedding Model',

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

@@ -172,11 +172,15 @@ function setupAndBoundary() {
     return `## Setup
 
 \`\`\`bash
-claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
-npx @claude-flow/cli@latest daemon start
-npx @claude-flow/cli@latest doctor --fix
+claude mcp add claude-flow -- npx -y ruflo@latest mcp start
+npx ruflo@latest doctor --fix
 \`\`\`
 
+> The background \`daemon\` is optional. It runs interval workers that each spawn
+> a headless \`claude\` session, so it consumes tokens continuously. Start it only
+> if you want those sweeps: \`npx ruflo@latest daemon start\` (self-stops after 12h
+> by default; \`--ttl 0\` to disable, \`daemon status --all\` to audit running daemons).
+
 **Agent tool** handles execution (agents, files, code, git). **MCP tools** handle coordination (swarm, memory, hooks). **CLI** is the same via Bash.`;
 }
 function buildAndTest() {

package/v3/@claude-flow/cli/dist/src/mcp-tools/agent-execute-core.d.ts

@@ -22,6 +22,7 @@ export interface AgentRecord {
     lastResult?: Record<string, unknown>;
 }
 export declare const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6";
+export declare function modelRejectsSamplingParams(model: string): boolean;
 export interface AnthropicCallInput {
     prompt: string;
     systemPrompt?: string;

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

@@ -46,6 +46,15 @@ const MODEL_MAP = {
     'opus-4.7': 'claude-opus-4-7',
     inherit: DEFAULT_ANTHROPIC_MODEL,
 };
+// #2357 — the adaptive-thinking family (Fable 5, Opus 4.8, Opus 4.7) removed
+// the sampling parameters (temperature/top_p/top_k); the Anthropic API
+// returns 400 "Extra inputs are not permitted" when any is present.
+// Prefix-match so dated snapshots (e.g. claude-opus-4-8-YYYYMMDD) are
+// covered. Applies only to the direct Anthropic path — the Ollama/OpenRouter
+// OpenAI-compat paths accept temperature and are unchanged.
+export function modelRejectsSamplingParams(model) {
+    return /^claude-(fable-5|opus-4-8|opus-4-7)/.test(model);
+}
 /**
  * Generic Anthropic Messages API call. No agent registry coupling — used
  * by agent_execute (with the agent's configured model) and by the WASM
@@ -76,7 +85,11 @@ export async function callAnthropicMessages(input) {
             apiKey: openrouterKey,
             baseUrl: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api',
             providerLabel: 'openrouter',
-            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || 'anthropic/claude-3.5-sonnet',
+            // #2357 Finding C: anthropic/claude-3.5-sonnet was retired Oct 2025.
+            // Default to the same canonical family the rest of the resolver uses
+            // (MODEL_MAP). `OPENROUTER_DEFAULT_MODEL` still wins for callers who
+            // want to pin a specific OpenRouter slug.
+            defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || 'anthropic/claude-sonnet-4-6',
         });
     }
     if (useOllama && ollamaKey) {
@@ -103,7 +116,13 @@ export async function callAnthropicMessages(input) {
             body: JSON.stringify({
                 model,
                 max_tokens: input.maxTokens || 1024,
-                temperature: typeof input.temperature === 'number' ? input.temperature : 0.7,
+                // #2357 — omit temperature for models that reject sampling params
+                // (Fable 5 / Opus 4.8 / Opus 4.7 → 400 "Extra inputs are not
+                // permitted"); keep the 0.7 default unchanged for models that still
+                // accept it (sonnet / haiku / opus ≤4.6).
+                ...(modelRejectsSamplingParams(model)
+                    ? {}
+                    : { temperature: typeof input.temperature === 'number' ? input.temperature : 0.7 }),
                 // #8 prompt caching (hermes-agent pattern): mark the (often large,
                 // stable) system prompt as an ephemeral cache breakpoint so repeated
                 // agent_execute calls with the same system prompt hit Anthropic's
@@ -299,13 +318,15 @@ async function callOpenAICompat(input) {
 function resolveOpenAICompatModel(input, fallback) {
     if (!input)
         return fallback;
-    // Logical Claude names → OpenRouter Anthropic-vendored names
+    // Logical Claude names → OpenRouter Anthropic-vendored names.
+    // #2357 Finding C: the 3.5 / 3-opus slugs were retired Oct 2025; align with
+    // MODEL_MAP (claude-haiku-4-5 / claude-sonnet-4-6 / claude-opus-4-8).
     if (input === 'haiku')
-        return 'anthropic/claude-3.5-haiku';
+        return 'anthropic/claude-haiku-4-5';
     if (input === 'sonnet' || input === 'inherit')
-        return 'anthropic/claude-3.5-sonnet';
+        return 'anthropic/claude-sonnet-4-6';
     if (input === 'opus')
-        return 'anthropic/claude-3-opus';
+        return 'anthropic/claude-opus-4-8';
     return input;
 }
 function resolveOllamaModel(input) {

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

@@ -562,26 +562,35 @@ async function rescueAgentdbEmbedder(agentdb) {
     // own embed() does the right thing and we should not interpose.
     if (emb.pipeline)
         return;
-    let generateEmbedding = null;
+    let localEmbed = null;
     try {
         const mod = (await import('./memory-initializer.js'));
-        generateEmbedding = mod.generateEmbedding ?? null;
+        localEmbed = mod.generateLocalEmbedding ?? null;
     }
     catch {
         return; // can't import the rescuer — leave the mock fallback alone
     }
-    if (!generateEmbedding)
+    if (!localEmbed)
         return;
-    const embed = generateEmbedding;
-    // Probe once to confirm the rescuer actually returns real (non-zero) vectors.
-    // If our own fallback chain also dead-ends in mock embeddings, leave
-    // agentdb as-is rather than swapping one mock for another.
+    const embed = localEmbed;
+    // Probe once to confirm the rescuer actually returns REAL ONNX vectors
+    // (#2312: the old probe only checked non-zero, which the deterministic
+    // hash fallback also satisfies — so it "rescued" agentdb's mock with our
+    // own mock and reported it as real). Require backend === 'onnx'.
     try {
         const probe = await embed('rescue-probe');
         const arr = probe?.embedding ? Array.from(probe.embedding) : [];
         const hasSignal = arr.length > 0 && arr.some((v) => Math.abs(v) > 1e-9);
-        if (!hasSignal)
+        if (!hasSignal || probe.backend !== 'onnx') {
+            // Local chain is also degraded — leave agentdb's embedder alone, but
+            // tag it so bridgeGenerateEmbedding's AUDIT-#3 isMock check reports
+            // backend='mock' truthfully instead of labeling mock vectors 'onnx'.
+            try {
+                emb.backend = 'mock';
+            }
+            catch { /* frozen */ }
             return;
+        }
     }
     catch {
         return;

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

@@ -269,6 +269,27 @@ export declare function generateEmbedding(text: string): Promise<{
     model: string;
     backend: 'onnx' | 'mock';
 }>;
+/**
+ * Generate an embedding using ONLY the local model chain (transformers.js /
+ * ruvector ONNX / hash fallback) — never the AgentDB bridge.
+ *
+ * #2312: this MUST stay bridge-free. `memory-bridge.ts` rescues a degraded
+ * agentdb embedder by delegating to this module; if that delegation went
+ * through `generateEmbedding` (bridge-first), the call would re-enter the
+ * patched `agentdb.embedder.embed` and recurse unboundedly:
+ *
+ *   generateEmbedding → bridgeGenerateEmbedding → embedder.embed (patched)
+ *     → generateEmbedding → … (heap OOM at ~4 GB on CI, no stack overflow
+ *     because the cycle is async/microtask-driven)
+ *
+ * Keeping the local chain as its own export breaks that cycle structurally.
+ */
+export declare function generateLocalEmbedding(text: string): Promise<{
+    embedding: number[];
+    dimensions: number;
+    model: string;
+    backend: 'onnx' | 'mock';
+}>;
 /**
  * Generate embeddings for multiple texts
  * Uses parallel execution for API-based providers (2-4x faster)

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

@@ -10,7 +10,30 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { createRequire } from 'node:module';
 import { readFileMaybeEncrypted, writeFileRestricted } from '../fs-secure.js';
+/**
+ * #2356 — cached, synchronous capability probe for @ruvector/core. `getHNSWStatus`
+ * is sync and is called by `neural status` in a fresh process that never warms
+ * the lazy HNSW singleton, so reporting availability off the warm singleton
+ * alone produced a false "Not loaded — @ruvector/core not available" even when
+ * the package is installed and exposes VectorDb. Resolving the module (without
+ * importing/initializing it) is a faithful, cheap availability signal.
+ */
+let _ruvectorCoreResolvable;
+function isRuvectorCoreResolvable() {
+    if (_ruvectorCoreResolvable !== undefined)
+        return _ruvectorCoreResolvable;
+    try {
+        const req = createRequire(import.meta.url);
+        req.resolve('@ruvector/core');
+        _ruvectorCoreResolvable = true;
+    }
+    catch {
+        _ruvectorCoreResolvable = false;
+    }
+    return _ruvectorCoreResolvable;
+}
 /**
  * #1854: previously every site that needed the memory directory hardcoded
  * `getMemoryRoot()`, so the documented config entry
@@ -671,8 +694,13 @@ export function getHNSWStatus() {
             dimensions: hnswIndex?.dimensions ?? 384
         };
     }
+    // #2356: `available` now reflects real capability (index already loaded OR
+    // @ruvector/core installed and resolvable), not merely whether the lazy
+    // singleton happens to be warm in this process. `initialized` still reports
+    // whether the in-process index is actually loaded, so callers can tell
+    // "installed but not yet loaded" apart from "loaded".
     return {
-        available: hnswIndex !== null,
+        available: hnswIndex !== null || isRuvectorCoreResolvable(),
         initialized: hnswIndex?.initialized ?? false,
         entryCount: hnswIndex?.entries.size ?? 0,
         dimensions: hnswIndex?.dimensions ?? 384
@@ -1581,6 +1609,24 @@ export async function generateEmbedding(text) {
             return { ...bridgeResult, backend };
         }
     }
+    return generateLocalEmbedding(text);
+}
+/**
+ * Generate an embedding using ONLY the local model chain (transformers.js /
+ * ruvector ONNX / hash fallback) — never the AgentDB bridge.
+ *
+ * #2312: this MUST stay bridge-free. `memory-bridge.ts` rescues a degraded
+ * agentdb embedder by delegating to this module; if that delegation went
+ * through `generateEmbedding` (bridge-first), the call would re-enter the
+ * patched `agentdb.embedder.embed` and recurse unboundedly:
+ *
+ *   generateEmbedding → bridgeGenerateEmbedding → embedder.embed (patched)
+ *     → generateEmbedding → … (heap OOM at ~4 GB on CI, no stack overflow
+ *     because the cycle is async/microtask-driven)
+ *
+ * Keeping the local chain as its own export breaks that cycle structurally.
+ */
+export async function generateLocalEmbedding(text) {
     // Ensure model is loaded
     if (!embeddingModelState?.loaded) {
         await loadEmbeddingModel();

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

@@ -8,6 +8,19 @@ import * as path from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
+// On Windows, `npm` is a shell script (no `.exe`) and `npm.cmd` is a batch
+// wrapper. Since Node 18.20.2 / 20.12.2 (CVE-2024-27980) the runtime refuses
+// to spawn `.cmd`/`.bat` files directly and throws `spawn EINVAL` — the only
+// supported invocation is via a real `.exe` shell. We wrap every npm call
+// through `cmd.exe /d /s /c npm <args>`, which keeps Node's safe array-form
+// argument escaping intact and avoids both ENOENT and EINVAL.
+const isWindows = process.platform === 'win32';
+function runNpm(args, timeoutMs) {
+    if (isWindows) {
+        return execFileAsync('cmd.exe', ['/d', '/s', '/c', 'npm', ...args], { timeout: timeoutMs });
+    }
+    return execFileAsync('npm', args, { timeout: timeoutMs });
+}
 /**
  * Validate npm package name to prevent shell injection (S-3)
  */
@@ -105,7 +118,7 @@ export class PluginManager {
             validatePackageName(versionSpec);
             // Use npm to install (array form prevents shell injection)
             console.log(`[PluginManager] Installing ${versionSpec}...`);
-            await execFileAsync('npm', ['install', '--prefix', this.config.pluginsDir, versionSpec], { timeout: 120000 });
+            await runNpm(['install', '--prefix', this.config.pluginsDir, versionSpec], 120000);
             // Get installed version
             const packageJsonPath = path.join(installDir, packageName, 'package.json');
             let installedVersion = version || 'latest';
@@ -210,7 +223,7 @@ export class PluginManager {
             // For npm-installed plugins, remove from node_modules
             if (plugin.source === 'npm') {
                 validatePackageName(packageName);
-                await execFileAsync('npm', ['uninstall', '--prefix', this.config.pluginsDir, packageName], { timeout: 60000 });
+                await runNpm(['uninstall', '--prefix', this.config.pluginsDir, packageName], 60000);
             }
             // Remove from manifest
             delete this.manifest.plugins[packageName];
@@ -333,7 +346,7 @@ export class PluginManager {
             // Validate package name to prevent injection (S-3)
             validatePackageName(versionSpec);
             // Reinstall with new version (array form prevents shell injection)
-            await execFileAsync('npm', ['install', '--prefix', this.config.pluginsDir, versionSpec], { timeout: 120000 });
+            await runNpm(['install', '--prefix', this.config.pluginsDir, versionSpec], 120000);
             // Update manifest
             const installDir = path.join(this.config.pluginsDir, 'node_modules');
             const packageJsonPath = path.join(installDir, packageName, 'package.json');

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

@@ -55,6 +55,8 @@ export interface DaemonConfig {
         maxCpuLoad: number;
         minFreeMemoryPercent: number;
     };
+    ttlMs: number;
+    idleShutdownMs: number;
     workers: WorkerConfig[];
 }
 /**
@@ -65,6 +67,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private workers;
     private timers;
     private queuePollTimer?;
+    private lifecycleTimer?;
     private running;
     private startedAt?;
     private projectRoot;
@@ -222,6 +225,30 @@ export declare class WorkerDaemon extends EventEmitter {
      * Stop the daemon and all workers
      */
     stop(): Promise<void>;
+    /**
+     * #2356 — Self-terminating lifecycle monitor. A daemon with no upper bound
+     * on its lifetime is the documented root cause of multi-day token leaks:
+     * each interval worker spawns a headless `claude --print` sweep, so a daemon
+     * left running for days dispatches tens of thousands of sessions invisibly.
+     * This timer enforces a max age (`ttlMs`) and an optional idle window
+     * (`idleShutdownMs`), shutting the daemon down gracefully when either trips.
+     * Checked once a minute and `unref()`'d so it never keeps the process alive
+     * on its own. A no-op when both limits are disabled (0).
+     */
+    private startLifecycleMonitor;
+    /**
+     * Most recent worker start/finish time across all workers (epoch ms), or
+     * null if no worker has ever started. Used for idle-shutdown detection.
+     */
+    private lastWorkerActivityMs;
+    /**
+     * Graceful self-shutdown triggered by the lifecycle monitor. Mirrors the
+     * signal-handler path (`stop()` then `process.exit(0)`) because the
+     * foreground keep-alive in the daemon command is a *ref'd* `setInterval`
+     * that would otherwise hold the process open after `stop()` clears the
+     * service timers — leaving a zombie that reports stopped but never exits.
+     */
+    private selfShutdown;
     /**
      * Get daemon status
      */

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

@@ -27,6 +27,30 @@ const DEFAULT_WORKERS = [
 // Worker timeout — must exceed the longest per-worker headless timeout (15 min for audit/refactor).
 // Previously 5 min, which caused orphan processes when daemon timeout fired before executor timeout (#1117).
 const DEFAULT_WORKER_TIMEOUT_MS = 16 * 60 * 1000;
+// #2356 — Self-terminating lifecycle defaults. A background daemon with no
+// upper bound on its lifetime runs until the box reboots; in the field this
+// leaked tens of thousands of headless `claude --print` sweeps over many days
+// (one observed daemon ran 19 days). A 12h default age cap (matching the
+// pacphi/ruflo-machine-ref kit's proven value) heals a forgotten daemon within
+// half a day; set RUFLO_DAEMON_TTL_SECS=0 (or `--ttl 0`) to opt out. Idle
+// shutdown is opt-in (0 = disabled) since a legitimately quiet daemon is not a leak.
+const DEFAULT_DAEMON_TTL_MS = 12 * 60 * 60 * 1000;
+const DEFAULT_DAEMON_IDLE_SHUTDOWN_MS = 0;
+/**
+ * Read a non-negative seconds value from an env var and return it as ms.
+ * Unlike the `parseInt(x) || default` idiom used elsewhere, an explicit `0`
+ * is honored (it disables the corresponding limit) rather than falling back
+ * to the default. Invalid / negative / absent values fall back.
+ */
+function readEnvSecsAsMs(name, defaultMs) {
+    const raw = process.env[name];
+    if (raw === undefined || raw.trim() === '')
+        return defaultMs;
+    const secs = Number.parseInt(raw, 10);
+    if (!Number.isFinite(secs) || secs < 0)
+        return defaultMs;
+    return secs * 1000;
+}
 /**
  * Worker Daemon - Manages background workers with Node.js
  */
@@ -37,6 +61,9 @@ export class WorkerDaemon extends EventEmitter {
     // #1845: separate timer for the MCP-dispatch queue poller. Kept off
     // the per-worker map so stop() clears both kinds without confusion.
     queuePollTimer;
+    // #2356: separate timer that enforces the daemon's max-age TTL + idle
+    // shutdown. Cleared in stop() alongside the worker/queue timers.
+    lifecycleTimer;
     running = false;
     startedAt;
     projectRoot;
@@ -92,6 +119,11 @@ export class WorkerDaemon extends EventEmitter {
                 maxCpuLoad: config?.resourceThresholds?.maxCpuLoad ?? fileConfig.maxCpuLoad ?? smartMaxCpuLoad,
                 minFreeMemoryPercent: config?.resourceThresholds?.minFreeMemoryPercent ?? fileConfig.minFreeMemoryPercent ?? defaultMinFreeMemory,
             },
+            // #2356 — precedence: constructor arg > config.json (daemon.ttlSecs) >
+            // env (RUFLO_DAEMON_TTL_SECS) > built-in default. readEnvSecsAsMs folds
+            // env-or-default and honors an explicit 0 (disable).
+            ttlMs: config?.ttlMs ?? fileConfig.ttlMs ?? readEnvSecsAsMs('RUFLO_DAEMON_TTL_SECS', DEFAULT_DAEMON_TTL_MS),
+            idleShutdownMs: config?.idleShutdownMs ?? fileConfig.idleShutdownMs ?? readEnvSecsAsMs('RUFLO_DAEMON_IDLE_SECS', DEFAULT_DAEMON_IDLE_SHUTDOWN_MS),
             workers: config?.workers ?? DEFAULT_WORKERS,
         };
         // Setup graceful shutdown handlers
@@ -274,12 +306,19 @@ export class WorkerDaemon extends EventEmitter {
             const rawMinMem = cfg['daemon.resourceThresholds.minFreeMemoryPercent'] ?? raw['daemon.resourceThresholds.minFreeMemoryPercent'];
             const rawMaxConcurrent = cfg['daemon.maxConcurrent'] ?? raw['daemon.maxConcurrent'];
             const rawTimeout = cfg['daemon.workerTimeoutMs'] ?? raw['daemon.workerTimeoutMs'];
+            // #2356 — lifecycle limits are configured in SECONDS in config.json
+            // (`daemon.ttlSecs` / `daemon.idleSecs`) for parity with the CLI flag
+            // and env var; stored internally as ms. An explicit 0 disables.
+            const rawTtl = cfg['daemon.ttlSecs'] ?? raw['daemon.ttlSecs'];
+            const rawIdle = cfg['daemon.idleSecs'] ?? raw['daemon.idleSecs'];
             return {
                 autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
                 maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
                 workerTimeoutMs: (typeof rawTimeout === 'number' && rawTimeout > 0) ? rawTimeout : undefined,
                 maxCpuLoad: (typeof rawCpuLoad === 'number' && rawCpuLoad > 0 && rawCpuLoad < 1000) ? rawCpuLoad : undefined,
                 minFreeMemoryPercent: (typeof rawMinMem === 'number' && rawMinMem >= 0 && rawMinMem <= 100) ? rawMinMem : undefined,
+                ttlMs: (typeof rawTtl === 'number' && rawTtl >= 0) ? rawTtl * 1000 : undefined,
+                idleShutdownMs: (typeof rawIdle === 'number' && rawIdle >= 0) ? rawIdle * 1000 : undefined,
             };
         }
         catch {
@@ -668,6 +707,9 @@ export class WorkerDaemon extends EventEmitter {
         if (typeof this.queuePollTimer.unref === 'function') {
             this.queuePollTimer.unref();
         }
+        // #2356: self-terminating lifecycle. Without an upper bound on lifetime a
+        // forgotten daemon keeps dispatching headless worker sweeps for days.
+        this.startLifecycleMonitor();
         // Save state
         this.saveState();
         this.log('info', `Daemon started (PID: ${process.pid}, CPUs: ${cpus().length}, workers: ${this.config.workers.filter(w => w.enabled).length}, maxCpuLoad: ${this.config.resourceThresholds.maxCpuLoad}, minFreeMemoryPercent: ${this.config.resourceThresholds.minFreeMemoryPercent}%)`);
@@ -762,12 +804,93 @@ export class WorkerDaemon extends EventEmitter {
             clearInterval(this.queuePollTimer);
             this.queuePollTimer = undefined;
         }
+        // #2356: stop the TTL/idle lifecycle monitor.
+        if (this.lifecycleTimer) {
+            clearInterval(this.lifecycleTimer);
+            this.lifecycleTimer = undefined;
+        }
         this.running = false;
         this.removePidFile();
         this.saveState();
         this.emit('stopped', { stoppedAt: new Date() });
         this.log('info', 'Daemon stopped');
     }
+    /**
+     * #2356 — Self-terminating lifecycle monitor. A daemon with no upper bound
+     * on its lifetime is the documented root cause of multi-day token leaks:
+     * each interval worker spawns a headless `claude --print` sweep, so a daemon
+     * left running for days dispatches tens of thousands of sessions invisibly.
+     * This timer enforces a max age (`ttlMs`) and an optional idle window
+     * (`idleShutdownMs`), shutting the daemon down gracefully when either trips.
+     * Checked once a minute and `unref()`'d so it never keeps the process alive
+     * on its own. A no-op when both limits are disabled (0).
+     */
+    startLifecycleMonitor() {
+        const ttlMs = this.config.ttlMs;
+        const idleMs = this.config.idleShutdownMs;
+        if ((!ttlMs || ttlMs <= 0) && (!idleMs || idleMs <= 0)) {
+            return; // both limits disabled — preserve legacy run-until-stopped behavior
+        }
+        const CHECK_INTERVAL_MS = 60_000;
+        this.lifecycleTimer = setInterval(() => {
+            if (!this.running)
+                return;
+            const now = Date.now();
+            const startedMs = this.startedAt?.getTime() ?? now;
+            if (ttlMs > 0 && now - startedMs >= ttlMs) {
+                void this.selfShutdown(`max age ${Math.round(ttlMs / 1000)}s reached`);
+                return;
+            }
+            if (idleMs > 0) {
+                const lastActivity = this.lastWorkerActivityMs() ?? startedMs;
+                if (now - lastActivity >= idleMs) {
+                    void this.selfShutdown(`idle for ${Math.round(idleMs / 1000)}s (no worker activity)`);
+                }
+            }
+        }, CHECK_INTERVAL_MS);
+        if (typeof this.lifecycleTimer.unref === 'function') {
+            this.lifecycleTimer.unref();
+        }
+        const parts = [];
+        if (ttlMs > 0)
+            parts.push(`ttl=${Math.round(ttlMs / 1000)}s`);
+        if (idleMs > 0)
+            parts.push(`idle=${Math.round(idleMs / 1000)}s`);
+        this.log('info', `Lifecycle monitor active (${parts.join(', ')})`);
+    }
+    /**
+     * Most recent worker start/finish time across all workers (epoch ms), or
+     * null if no worker has ever started. Used for idle-shutdown detection.
+     */
+    lastWorkerActivityMs() {
+        let latest = null;
+        for (const state of this.workers.values()) {
+            for (const t of [state.lastRun, state.lastStartedAt]) {
+                if (t) {
+                    const ms = t.getTime();
+                    if (latest === null || ms > latest)
+                        latest = ms;
+                }
+            }
+        }
+        return latest;
+    }
+    /**
+     * Graceful self-shutdown triggered by the lifecycle monitor. Mirrors the
+     * signal-handler path (`stop()` then `process.exit(0)`) because the
+     * foreground keep-alive in the daemon command is a *ref'd* `setInterval`
+     * that would otherwise hold the process open after `stop()` clears the
+     * service timers — leaving a zombie that reports stopped but never exits.
+     */
+    async selfShutdown(reason) {
+        this.log('info', `Daemon self-shutdown: ${reason}`);
+        this.emit('self-shutdown', { reason });
+        try {
+            await this.stop();
+        }
+        catch { /* best-effort — we are exiting regardless */ }
+        process.exit(0);
+    }
     /**
      * Get daemon status
      */

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

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