claude-flow 3.10.41 → 3.10.43

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"d0b433ab-a217-4dde-9ea4-b2c996ac456a","pid":35460,"acquiredAt":1781120150954}

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.41",
+  "version": "3.10.43",
   "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/hooks.js

@@ -399,9 +399,20 @@ const postEditCommand = {
                 metrics,
                 timestamp: Date.now(),
             });
+            // #2352: the MCP handler returns `{success: false, error: "..."}` on
+            // validation failure (e.g. unsupported path shape) without throwing.
+            // Surface that explicitly instead of always printing the success line —
+            // Windows users were seeing `[OK]` while nothing reached the learning
+            // pipeline because absolute paths were rejected upstream.
+            const mcpFailed = result && result.success === false;
+            const mcpError = result?.error;
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
-                return { success: true, data: result };
+                return { success: !mcpFailed, exitCode: mcpFailed ? 1 : 0, data: result };
+            }
+            if (mcpFailed) {
+                output.printError(`Post-edit hook failed: ${mcpError || 'unknown error'}`);
+                return { success: false, exitCode: 1 };
             }
             output.writeln();
             output.printSuccess(`Outcome recorded for ${filePath}`);

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 };
@@ -773,7 +780,13 @@ const hooksCommand = {
                 skills: false,
                 commands: false,
                 agents: false,
-                helpers: false,
+                // #2350: helpers MUST ship with the hooks subcommand. The hook entries
+                // in settings.json point at `.claude/helpers/hook-handler.cjs`; if
+                // that file doesn't exist, settings-generator (#1744 fix) drops the
+                // hooks block entirely — so the one subcommand whose stated purpose
+                // is "Initialize only hooks configuration" produced settings.json
+                // with no `hooks` key while reporting "N hooks enabled".
+                helpers: true,
                 statusline: false,
                 mcp: false,
                 runtime: false,
@@ -964,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/mcp-tools/hooks-tools.js

@@ -2665,7 +2665,81 @@ export const hooksTrajectoryEnd = {
             }
             catch { /* intelligence module not loadable — keep sona-only behaviour */ }
         }
+        // #2351: when an agent calls trajectory-end with no recorded steps but a
+        // non-empty `feedback` string, the feedback was previously dropped on the
+        // floor — `patternsExtracted` reported 0 and `pattern-search` never
+        // surfaced it. Step-less trajectories are the common case for LLM agents
+        // (nothing forces step logging mid-task), and feedback is often the most
+        // distilled lesson available. Route it through the same store + embed
+        // path that pattern-store uses so it becomes searchable. Best-effort:
+        // failures here must not turn the trajectory-end call itself into a
+        // failure — the trajectory record was already persisted above.
+        let feedbackDistilled = { stored: false };
+        const hasSteps = !!trajectory && trajectory.steps.length > 0;
+        const trimmedFeedback = typeof feedback === 'string' ? feedback.trim() : '';
+        if (trajectory && !hasSteps && trimmedFeedback.length > 0) {
+            const distilledPatternId = `pattern-feedback-${trajectoryId}-${Date.now()}`;
+            const patternMetadata = {
+                sourceTrajectoryId: trajectoryId,
+                task: trajectory.task,
+                agent: trajectory.agent,
+                outcome: success ? 'success' : 'failure',
+                distilledFrom: 'trajectory-end-feedback',
+            };
+            // Modest default confidence — step-less feedback hasn't been validated
+            // by execution evidence the way a multi-step trajectory has.
+            const feedbackConfidence = success ? 0.6 : 0.4;
+            try {
+                const bridge = await import('../memory/memory-bridge.js');
+                const rb = await bridge.bridgeStorePattern({
+                    pattern: trimmedFeedback,
+                    type: 'trajectory-feedback',
+                    confidence: feedbackConfidence,
+                    metadata: patternMetadata,
+                });
+                if (rb?.success) {
+                    feedbackDistilled = { stored: true, patternId: rb.patternId, controller: rb.controller };
+                }
+            }
+            catch {
+                // Bridge unavailable — fall through to direct store
+            }
+            if (!feedbackDistilled.stored) {
+                try {
+                    const storeFn = await getRealStoreFunction();
+                    if (storeFn) {
+                        const r = await storeFn({
+                            key: distilledPatternId,
+                            value: JSON.stringify({
+                                pattern: trimmedFeedback,
+                                type: 'trajectory-feedback',
+                                confidence: feedbackConfidence,
+                                metadata: patternMetadata,
+                                timestamp: endedAt,
+                            }),
+                            namespace: 'pattern',
+                            generateEmbeddingFlag: true,
+                            tags: [
+                                'trajectory-feedback',
+                                success ? 'success' : 'failure',
+                                `confidence-${Math.round(feedbackConfidence * 100)}`,
+                            ],
+                        });
+                        if (r?.success) {
+                            feedbackDistilled = { stored: true, patternId: r.id || distilledPatternId, controller: 'store-fallback' };
+                        }
+                    }
+                }
+                catch {
+                    // Both paths failed — leave feedbackDistilled.stored = false.
+                }
+            }
+        }
         const learningTimeMs = Date.now() - startTime;
+        // patternsExtracted now reflects either recorded steps (the original
+        // semantics) OR a distilled feedback pattern (#2351), so step-less
+        // trajectories with useful feedback no longer report 0.
+        const patternsExtracted = (trajectory?.steps.length || 0) + (feedbackDistilled.stored ? 1 : 0);
         return {
             trajectoryId,
             success,
@@ -2678,7 +2752,11 @@ export const hooksTrajectoryEnd = {
                 sonaConfidence: sonaResult.confidence || undefined,
                 ewcConsolidation: ewcResult.consolidated,
                 ewcPenalty: ewcResult.penalty || undefined,
-                patternsExtracted: trajectory?.steps.length || 0,
+                patternsExtracted,
+                feedbackDistilled: feedbackDistilled.stored ? {
+                    patternId: feedbackDistilled.patternId,
+                    controller: feedbackDistilled.controller,
+                } : undefined,
                 learningTimeMs,
                 globalStatsTrajectoriesDelta: globalStatsDelta, // Round B: was 0, now reflects
             },

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

package/v3/@claude-flow/cli/dist/src/ruvector/neural-router.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Neural routing scaffold — `@ruvector/tiny-dancer` FastGRNN seam (#2334 Phase 1)
+ *
+ * Wires the optional neural path that ADR-026 originally described, behind a
+ * double gate that is OFF by default:
+ *
+ *   CLAUDE_FLOW_ROUTER_NEURAL=1                      — opt in to the neural path
+ *   CLAUDE_FLOW_ROUTER_MODEL_PATH=<x.safetensors>    — trained FastGRNN artifact
+ *
+ * Both must be set; otherwise `tryNeuralRoute` returns `null` immediately and
+ * the caller stays on the shipped heuristic + Thompson-bandit path. When the
+ * gate is open but anything fails (package not installed — it is an
+ * optionalDependency per ADR-124 — artifact missing/incompatible, runtime
+ * error), this module degrades gracefully: it returns `null`, never throws,
+ * and the caller reports `routedBy: 'bandit-fallback'` so the active path is
+ * observable rather than inferred from import success (ADR-086/074).
+ *
+ * Candidate modeling (#2334 Q3, provisional): the 3 model tiers are encoded as
+ * fixed candidates with deterministic placeholder embeddings (orthogonal-ish
+ * one-hot-block vectors). This is explicitly provisional — the trained Phase 2
+ * artifact defines what candidate embeddings mean, and this encoding is the
+ * scaffolding default until the maintainers answer #2334's candidate-modeling
+ * question. Until a real artifact exists the gate stays closed in practice, so
+ * the placeholder never influences routing.
+ *
+ * @module neural-router
+ */
+/** The three routable tiers — 'inherit' is never a neural candidate. */
+export type NeuralRoutableModel = 'haiku' | 'sonnet' | 'opus';
+export interface NeuralRouteDecision {
+    model: NeuralRoutableModel;
+    confidence: number;
+    uncertainty: number;
+    inferenceTimeUs: number;
+}
+/** True when the user has opted in AND pointed at a model artifact. */
+export declare function neuralRoutingEnabled(): boolean;
+/** Reset cached state — for tests. */
+export declare function resetNeuralRouter(): void;
+/**
+ * Attempt a neural routing decision for the given task embedding.
+ *
+ * Returns `null` (never throws) when the gate is closed, the package or
+ * artifact is unavailable, or inference fails — callers fall back to the
+ * bandit and report `routedBy: 'bandit-fallback'` (when the gate was open)
+ * or `'heuristic'` (when it never was).
+ */
+export declare function tryNeuralRoute(embedding: number[]): Promise<NeuralRouteDecision | null>;
+//# sourceMappingURL=neural-router.d.ts.map

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

@@ -0,0 +1,132 @@
+/**
+ * Neural routing scaffold — `@ruvector/tiny-dancer` FastGRNN seam (#2334 Phase 1)
+ *
+ * Wires the optional neural path that ADR-026 originally described, behind a
+ * double gate that is OFF by default:
+ *
+ *   CLAUDE_FLOW_ROUTER_NEURAL=1                      — opt in to the neural path
+ *   CLAUDE_FLOW_ROUTER_MODEL_PATH=<x.safetensors>    — trained FastGRNN artifact
+ *
+ * Both must be set; otherwise `tryNeuralRoute` returns `null` immediately and
+ * the caller stays on the shipped heuristic + Thompson-bandit path. When the
+ * gate is open but anything fails (package not installed — it is an
+ * optionalDependency per ADR-124 — artifact missing/incompatible, runtime
+ * error), this module degrades gracefully: it returns `null`, never throws,
+ * and the caller reports `routedBy: 'bandit-fallback'` so the active path is
+ * observable rather than inferred from import success (ADR-086/074).
+ *
+ * Candidate modeling (#2334 Q3, provisional): the 3 model tiers are encoded as
+ * fixed candidates with deterministic placeholder embeddings (orthogonal-ish
+ * one-hot-block vectors). This is explicitly provisional — the trained Phase 2
+ * artifact defines what candidate embeddings mean, and this encoding is the
+ * scaffolding default until the maintainers answer #2334's candidate-modeling
+ * question. Until a real artifact exists the gate stays closed in practice, so
+ * the placeholder never influences routing.
+ *
+ * @module neural-router
+ */
+import { existsSync } from 'fs';
+// ============================================================================
+// Gate & lifecycle
+// ============================================================================
+/** True when the user has opted in AND pointed at a model artifact. */
+export function neuralRoutingEnabled() {
+    return process.env.CLAUDE_FLOW_ROUTER_NEURAL === '1'
+        && !!process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH;
+}
+// Cached router instance + a sticky failure latch so a broken install/artifact
+// costs one failed load, not one per routing call.
+let routerInstance = null;
+let loadFailed = false;
+/** Reset cached state — for tests. */
+export function resetNeuralRouter() {
+    routerInstance = null;
+    loadFailed = false;
+}
+async function loadRouter() {
+    if (routerInstance)
+        return routerInstance;
+    if (loadFailed)
+        return null;
+    const modelPath = process.env.CLAUDE_FLOW_ROUTER_MODEL_PATH;
+    if (!modelPath || !existsSync(modelPath)) {
+        loadFailed = true;
+        return null;
+    }
+    try {
+        // Dynamic import of an optionalDependency (ADR-124): absent on installs
+        // where the native binding failed or was skipped — degrade, don't throw.
+        const mod = await import('@ruvector/tiny-dancer');
+        const RouterCtor = mod.Router;
+        if (!RouterCtor) {
+            loadFailed = true;
+            return null;
+        }
+        routerInstance = new RouterCtor({ modelPath });
+        return routerInstance;
+    }
+    catch {
+        loadFailed = true;
+        return null;
+    }
+}
+// ============================================================================
+// Candidate encoding (provisional — see header + #2334 Q3)
+// ============================================================================
+const TIER_ORDER = ['haiku', 'sonnet', 'opus'];
+/**
+ * Deterministic placeholder embedding for a tier candidate: a block one-hot
+ * over the embedding dimensionality. Replaced by whatever the Phase 2 trained
+ * artifact defines as candidate space.
+ */
+function tierCandidateEmbedding(tierIndex, dim) {
+    const v = new Array(dim).fill(0);
+    const block = Math.max(1, Math.floor(dim / TIER_ORDER.length));
+    const start = tierIndex * block;
+    for (let i = start; i < Math.min(start + block, dim); i++)
+        v[i] = 1 / Math.sqrt(block);
+    return v;
+}
+// ============================================================================
+// Routing
+// ============================================================================
+/**
+ * Attempt a neural routing decision for the given task embedding.
+ *
+ * Returns `null` (never throws) when the gate is closed, the package or
+ * artifact is unavailable, or inference fails — callers fall back to the
+ * bandit and report `routedBy: 'bandit-fallback'` (when the gate was open)
+ * or `'heuristic'` (when it never was).
+ */
+export async function tryNeuralRoute(embedding) {
+    if (!neuralRoutingEnabled())
+        return null;
+    if (!embedding || embedding.length === 0)
+        return null;
+    const router = await loadRouter();
+    if (!router)
+        return null;
+    try {
+        const response = await router.route({
+            queryEmbedding: embedding,
+            candidates: TIER_ORDER.map((tier, i) => ({
+                id: tier,
+                embedding: tierCandidateEmbedding(i, embedding.length),
+                metadata: JSON.stringify({ tier }),
+            })),
+        });
+        const best = response.decisions?.[0];
+        if (!best || !TIER_ORDER.includes(best.candidateId))
+            return null;
+        return {
+            model: best.candidateId,
+            confidence: best.confidence,
+            uncertainty: best.uncertainty,
+            inferenceTimeUs: response.inferenceTimeUs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=neural-router.js.map

package/v3/@claude-flow/cli/dist/src/ruvector/router-trajectory.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Router trajectory collection (#2334 Phase 1)
+ *
+ * Opt-in per-decision dataset collection for the model router. The persisted
+ * bandit state (`.swarm/model-router-state.json`) keeps only aggregates —
+ * 9 Beta(α,β) cells and a capped/truncated history — which is not trainable
+ * material for the Phase 2 FastGRNN tier-classifier. This sidecar captures
+ * the per-example rows that training needs:
+ *
+ *   decision rows: { taskHash, task, embedding?, complexity, features,
+ *                    model, confidence, uncertainty, routedBy, ts }
+ *   outcome rows:  { taskHash, model, outcome, ts }
+ *
+ * joined offline on `taskHash` (sha256-16 of the task text).
+ *
+ * OFF by default. Enable with CLAUDE_FLOW_ROUTER_TRAJECTORY=1. Rows append to
+ * `.swarm/model-router-trajectories.jsonl` — local-only, same trust domain as
+ * the existing state file, but unlike it the rows contain full task text (up
+ * to 500 chars) and raw embeddings, which is why this is opt-in rather than
+ * always-on.
+ *
+ * Writes are best-effort: any fs error is swallowed (collection must never
+ * break routing), matching the state-file behavior in model-router.ts.
+ *
+ * @module router-trajectory
+ */
+export declare const TRAJECTORY_FILE = ".swarm/model-router-trajectories.jsonl";
+export declare function trajectoryCollectionEnabled(): boolean;
+/** Join key: first 16 hex chars of sha256(task). */
+export declare function taskHash(task: string): string;
+export interface TrajectoryDecisionRow {
+    v: number;
+    type: 'decision';
+    ts: string;
+    taskHash: string;
+    /** Task text, capped at 500 chars (cf. learningHistory's 100). */
+    task: string;
+    /** Raw embedding when one was threaded through route(); else omitted. */
+    embedding?: number[];
+    complexity: number;
+    features: {
+        lexicalComplexity: number;
+        semanticDepth: number;
+        taskScope: number;
+        uncertaintyLevel: number;
+    };
+    model: string;
+    confidence: number;
+    uncertainty: number;
+    routedBy: string;
+}
+export interface TrajectoryOutcomeRow {
+    v: number;
+    type: 'outcome';
+    ts: string;
+    taskHash: string;
+    model: string;
+    outcome: 'success' | 'failure' | 'escalated';
+}
+export declare function recordTrajectoryDecision(task: string, embedding: number[] | undefined, complexity: TrajectoryDecisionRow['features'] & {
+    score: number;
+}, decision: {
+    model: string;
+    confidence: number;
+    uncertainty: number;
+    routedBy: string;
+}): void;
+export declare function recordTrajectoryOutcome(task: string, model: string, outcome: 'success' | 'failure' | 'escalated'): void;
+//# sourceMappingURL=router-trajectory.d.ts.map

package/v3/@claude-flow/cli/dist/src/ruvector/router-trajectory.js

@@ -0,0 +1,87 @@
+/**
+ * Router trajectory collection (#2334 Phase 1)
+ *
+ * Opt-in per-decision dataset collection for the model router. The persisted
+ * bandit state (`.swarm/model-router-state.json`) keeps only aggregates —
+ * 9 Beta(α,β) cells and a capped/truncated history — which is not trainable
+ * material for the Phase 2 FastGRNN tier-classifier. This sidecar captures
+ * the per-example rows that training needs:
+ *
+ *   decision rows: { taskHash, task, embedding?, complexity, features,
+ *                    model, confidence, uncertainty, routedBy, ts }
+ *   outcome rows:  { taskHash, model, outcome, ts }
+ *
+ * joined offline on `taskHash` (sha256-16 of the task text).
+ *
+ * OFF by default. Enable with CLAUDE_FLOW_ROUTER_TRAJECTORY=1. Rows append to
+ * `.swarm/model-router-trajectories.jsonl` — local-only, same trust domain as
+ * the existing state file, but unlike it the rows contain full task text (up
+ * to 500 chars) and raw embeddings, which is why this is opt-in rather than
+ * always-on.
+ *
+ * Writes are best-effort: any fs error is swallowed (collection must never
+ * break routing), matching the state-file behavior in model-router.ts.
+ *
+ * @module router-trajectory
+ */
+import { createHash } from 'crypto';
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+export const TRAJECTORY_FILE = '.swarm/model-router-trajectories.jsonl';
+/** Schema version stamped on every row so offline training can dispatch. */
+const ROW_VERSION = 1;
+export function trajectoryCollectionEnabled() {
+    return process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY === '1';
+}
+/** Join key: first 16 hex chars of sha256(task). */
+export function taskHash(task) {
+    return createHash('sha256').update(task).digest('hex').slice(0, 16);
+}
+function appendRow(row) {
+    try {
+        const fullPath = join(process.cwd(), TRAJECTORY_FILE);
+        const dir = dirname(fullPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(fullPath, JSON.stringify(row) + '\n');
+    }
+    catch {
+        // Best-effort: collection must never break routing.
+    }
+}
+export function recordTrajectoryDecision(task, embedding, complexity, decision) {
+    if (!trajectoryCollectionEnabled())
+        return;
+    appendRow({
+        v: ROW_VERSION,
+        type: 'decision',
+        ts: new Date().toISOString(),
+        taskHash: taskHash(task),
+        task: task.slice(0, 500),
+        ...(embedding && embedding.length > 0 ? { embedding } : {}),
+        complexity: complexity.score,
+        features: {
+            lexicalComplexity: complexity.lexicalComplexity,
+            semanticDepth: complexity.semanticDepth,
+            taskScope: complexity.taskScope,
+            uncertaintyLevel: complexity.uncertaintyLevel,
+        },
+        model: decision.model,
+        confidence: decision.confidence,
+        uncertainty: decision.uncertainty,
+        routedBy: decision.routedBy,
+    });
+}
+export function recordTrajectoryOutcome(task, model, outcome) {
+    if (!trajectoryCollectionEnabled())
+        return;
+    appendRow({
+        v: ROW_VERSION,
+        type: 'outcome',
+        ts: new Date().toISOString(),
+        taskHash: taskHash(task),
+        model,
+        outcome,
+    });
+}
+//# sourceMappingURL=router-trajectory.js.map

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.41",
+  "version": "3.10.43",
   "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",