claude-flow 3.5.22 → 3.5.24

package/README.md

@@ -25,7 +25,7 @@
 
 </div>
 
-> **Why Ruflo?** Claude Flow is now Ruflo — named by Ruv, who loves Rust, flow states, and building things that feel inevitable. The "Ru" is the Ruv. The "flo" is the flow. Underneath, WASM kernels written in Rust power the policy engine, embeddings, and proof system. 5,800 commits later, the alpha is over. This is v3.5.
+> **Why Ruflo?** Claude Flow is now Ruflo — named by Ruv, who loves Rust, flow states, and building things that feel inevitable. The "Ru" is the Ruv. The "flo" is the flow. Underneath, WASM kernels written in Rust power the policy engine, embeddings, and proof system. 5,900+ commits later, the alpha is over. This is v3.5.
 
 ## Getting into the Flow
 
@@ -161,6 +161,8 @@ curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/claude-flow@main/scripts/install.s
 npx ruflo@latest init --wizard
 ```
 
+> **New to Ruflo?** You don't need to learn 259 MCP tools or 26 CLI commands. After running `init`, just use Claude Code normally — the hooks system automatically routes tasks to the right agents, learns from successful patterns, and coordinates multi-agent work in the background. The advanced tools exist for fine-grained control when you need it.
+
 ---
 ### Key Capabilities
 
@@ -697,12 +699,12 @@ claude mcp add ruflo -- npx -y ruflo@latest mcp start
 claude mcp list
 ```
 
-Once added, Claude Code can use all 175+ ruflo MCP tools directly:
+Once added, Claude Code can use all 259 ruflo MCP tools directly:
 - `swarm_init` - Initialize agent swarms
 - `agent_spawn` - Spawn specialized agents
 - `memory_search` - Search patterns with HNSW vector search
 - `hooks_route` - Intelligent task routing
-- And 170+ more tools...
+- And 255+ more tools...
 
 ---
 ## What is it exactly? Agents that learn, build and work perpetually. 
@@ -752,7 +754,7 @@ Ruflo v3 introduces **self-learning neural capabilities** that no other agent or
 
 | Feature | Ruflo v3 | CrewAI | LangGraph | AutoGen | Manus |
 |---------|----------------|--------|-----------|---------|-------|
-| **MCP Integration** | ✅ Native (170+ tools) | ⛔ | ⛔ | ⛔ | ⛔ |
+| **MCP Integration** | ✅ Native (259 tools) | ⛔ | ⛔ | ⛔ | ⛔ |
 | **Skills System** | ✅ 42+ pre-built | ⛔ | ⛔ | ⛔ | Limited |
 | **Stream Pipelines** | ✅ JSON chains | ⛔ | Via code | ⛔ | ⛔ |
 | **Pair Programming** | ✅ Driver/Navigator | ⛔ | ⛔ | ⛔ | ⛔ |
@@ -2158,7 +2160,7 @@ npx ruflo@v3alpha worker status
 | `agentConfigs` | 15 V3 agent configurations | Agent testing |
 | `memoryEntries` | Patterns, rules, embeddings | Memory testing |
 | `swarmConfigs` | V3 default, minimal, mesh, hierarchical | Swarm testing |
-| `mcpTools` | 175+ tool definitions | MCP testing |
+| `mcpTools` | 259 tool definitions | MCP testing |
 
 </details>
 
@@ -5018,9 +5020,9 @@ npx agentic-flow mcp stdio
 </details>
 
 <details>
-<summary>🔧 <strong>MCP Tools</strong> — 213+ Integration Tools</summary>
+<summary>🔧 <strong>MCP Tools</strong> — 259 Integration Tools</summary>
 
-Agentic-flow exposes 213+ MCP tools for integration:
+Agentic-flow exposes 259 MCP tools for integration:
 
 | Category | Tools | Examples |
 |----------|-------|----------|

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.22",
+  "version": "3.5.24",
   "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

@@ -25,7 +25,7 @@
 
 </div>
 
-> **Why Ruflo?** Claude Flow is now Ruflo — named by Ruv, who loves Rust, flow states, and building things that feel inevitable. The "Ru" is the Ruv. The "flo" is the flow. Underneath, WASM kernels written in Rust power the policy engine, embeddings, and proof system. 5,800 commits later, the alpha is over. This is v3.5.
+> **Why Ruflo?** Claude Flow is now Ruflo — named by Ruv, who loves Rust, flow states, and building things that feel inevitable. The "Ru" is the Ruv. The "flo" is the flow. Underneath, WASM kernels written in Rust power the policy engine, embeddings, and proof system. 5,900+ commits later, the alpha is over. This is v3.5.
 
 ## Getting into the Flow
 
@@ -161,6 +161,8 @@ curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/claude-flow@main/scripts/install.s
 npx ruflo@latest init --wizard
 ```
 
+> **New to Ruflo?** You don't need to learn 259 MCP tools or 26 CLI commands. After running `init`, just use Claude Code normally — the hooks system automatically routes tasks to the right agents, learns from successful patterns, and coordinates multi-agent work in the background. The advanced tools exist for fine-grained control when you need it.
+
 ---
 ### Key Capabilities
 
@@ -697,12 +699,12 @@ claude mcp add ruflo -- npx -y ruflo@latest mcp start
 claude mcp list
 ```
 
-Once added, Claude Code can use all 175+ ruflo MCP tools directly:
+Once added, Claude Code can use all 259 ruflo MCP tools directly:
 - `swarm_init` - Initialize agent swarms
 - `agent_spawn` - Spawn specialized agents
 - `memory_search` - Search patterns with HNSW vector search
 - `hooks_route` - Intelligent task routing
-- And 170+ more tools...
+- And 255+ more tools...
 
 ---
 ## What is it exactly? Agents that learn, build and work perpetually. 
@@ -752,7 +754,7 @@ Ruflo v3 introduces **self-learning neural capabilities** that no other agent or
 
 | Feature | Ruflo v3 | CrewAI | LangGraph | AutoGen | Manus |
 |---------|----------------|--------|-----------|---------|-------|
-| **MCP Integration** | ✅ Native (170+ tools) | ⛔ | ⛔ | ⛔ | ⛔ |
+| **MCP Integration** | ✅ Native (259 tools) | ⛔ | ⛔ | ⛔ | ⛔ |
 | **Skills System** | ✅ 42+ pre-built | ⛔ | ⛔ | ⛔ | Limited |
 | **Stream Pipelines** | ✅ JSON chains | ⛔ | Via code | ⛔ | ⛔ |
 | **Pair Programming** | ✅ Driver/Navigator | ⛔ | ⛔ | ⛔ | ⛔ |
@@ -2158,7 +2160,7 @@ npx ruflo@v3alpha worker status
 | `agentConfigs` | 15 V3 agent configurations | Agent testing |
 | `memoryEntries` | Patterns, rules, embeddings | Memory testing |
 | `swarmConfigs` | V3 default, minimal, mesh, hierarchical | Swarm testing |
-| `mcpTools` | 175+ tool definitions | MCP testing |
+| `mcpTools` | 259 tool definitions | MCP testing |
 
 </details>
 
@@ -5018,9 +5020,9 @@ npx agentic-flow mcp stdio
 </details>
 
 <details>
-<summary>🔧 <strong>MCP Tools</strong> — 213+ Integration Tools</summary>
+<summary>🔧 <strong>MCP Tools</strong> — 259 Integration Tools</summary>
 
-Agentic-flow exposes 213+ MCP tools for integration:
+Agentic-flow exposes 259 MCP tools for integration:
 
 | Category | Tools | Examples |
 |----------|-------|----------|

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

@@ -19,6 +19,8 @@ const startCommand = {
         { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
         { name: 'headless', type: 'boolean', description: 'Enable headless worker execution (E2B sandbox)' },
         { 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)' },
     ],
     examples: [
         { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
@@ -31,6 +33,37 @@ const startCommand = {
         const foreground = ctx.flags.foreground;
         const projectRoot = process.cwd();
         const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+        // Parse resource threshold overrides from CLI flags
+        const config = {};
+        const rawMaxCpu = ctx.flags['max-cpu-load'];
+        const rawMinMem = ctx.flags['min-free-memory'];
+        // Strict numeric pattern to prevent command injection when forwarding to subprocess (S1)
+        const NUMERIC_RE = /^\d+(\.\d+)?$/;
+        const sanitize = (s) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+        if (rawMaxCpu || rawMinMem) {
+            const thresholds = {};
+            if (rawMaxCpu) {
+                const val = parseFloat(rawMaxCpu);
+                if (NUMERIC_RE.test(rawMaxCpu) && isFinite(val) && val > 0 && val <= 1000) {
+                    thresholds.maxCpuLoad = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --max-cpu-load value: ${sanitize(rawMaxCpu)}`);
+                }
+            }
+            if (rawMinMem) {
+                const val = parseFloat(rawMinMem);
+                if (NUMERIC_RE.test(rawMinMem) && isFinite(val) && val >= 0 && val <= 100) {
+                    thresholds.minFreeMemoryPercent = val;
+                }
+                else if (!quiet) {
+                    output.printWarning(`Ignoring invalid --min-free-memory value: ${sanitize(rawMinMem)}`);
+                }
+            }
+            if (thresholds.maxCpuLoad !== undefined || thresholds.minFreeMemoryPercent !== undefined) {
+                config.resourceThresholds = thresholds;
+            }
+        }
         // Check if background daemon already running (skip if we ARE the daemon process)
         if (!isDaemonProcess) {
             const bgPid = getBackgroundDaemonPid(projectRoot);
@@ -43,7 +76,7 @@ const startCommand = {
         }
         // Background mode (default): fork a detached process
         if (!foreground) {
-            return startBackgroundDaemon(projectRoot, quiet);
+            return startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem);
         }
         // Foreground mode: run in current process (blocks terminal)
         try {
@@ -74,7 +107,7 @@ const startCommand = {
             if (!quiet) {
                 const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
                 spinner.start();
-                const daemon = await startDaemon(projectRoot);
+                const daemon = await startDaemon(projectRoot, config);
                 const status = daemon.getStatus();
                 spinner.succeed('Worker daemon started (foreground mode)');
                 output.writeln();
@@ -83,6 +116,8 @@ const startCommand = {
                     `Started: ${status.startedAt?.toISOString()}`,
                     `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
                     `Max Concurrent: ${status.config.maxConcurrent}`,
+                    `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                    `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
                 ].join('\n'), 'Daemon Status');
                 output.writeln();
                 output.writeln(output.bold('Scheduled Workers'));
@@ -120,7 +155,7 @@ const startCommand = {
                 await new Promise(() => { }); // Never resolves - daemon runs until killed
             }
             else {
-                await startDaemon(projectRoot);
+                await startDaemon(projectRoot, config);
                 await new Promise(() => { }); // Keep alive
             }
             return { success: true };
@@ -157,7 +192,7 @@ function validatePath(path, label) {
 /**
  * Start daemon as a detached background process
  */
-async function startBackgroundDaemon(projectRoot, quiet) {
+async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemory) {
     // Validate and resolve project root
     const resolvedRoot = resolve(projectRoot);
     validatePath(resolvedRoot, 'Project root');
@@ -199,10 +234,20 @@ async function startBackgroundDaemon(projectRoot, quiet) {
     };
     // Use spawn with explicit arguments instead of shell string interpolation
     // This prevents command injection via paths
-    const child = spawn(process.execPath, [
+    const spawnArgs = [
         cliPath,
-        'daemon', 'start', '--foreground', '--quiet'
-    ], spawnOpts);
+        'daemon', 'start', '--foreground', '--quiet',
+    ];
+    // Forward resource threshold flags to the foreground child process
+    // Validate with strict numeric pattern to prevent shell injection on Windows (S1)
+    const SPAWN_NUMERIC_RE = /^\d+(\.\d+)?$/;
+    if (maxCpuLoad && SPAWN_NUMERIC_RE.test(maxCpuLoad)) {
+        spawnArgs.push('--max-cpu-load', maxCpuLoad);
+    }
+    if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
+        spawnArgs.push('--min-free-memory', minFreeMemory);
+    }
+    const child = spawn(process.execPath, spawnArgs, spawnOpts);
     // Get PID from spawned process directly (no shell echo needed)
     const pid = child.pid;
     if (!pid || pid <= 0) {
@@ -371,6 +416,8 @@ const statusCommand = {
                 status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
                 `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
                 `Max Concurrent: ${status.config.maxConcurrent}`,
+                `Max CPU Load: ${status.config.resourceThresholds.maxCpuLoad}`,
+                `Min Free Memory: ${status.config.resourceThresholds.minFreeMemoryPercent}%`,
             ].filter(Boolean).join('\n'), 'RuFlo Daemon');
             output.writeln();
             output.writeln(output.bold('Worker Status'));

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

@@ -21,9 +21,11 @@ async function initCodexAction(ctx, options) {
         // Dynamic import of the Codex initializer with lazy loading fallback
         let CodexInitializer;
         // Try multiple resolution strategies for the @claude-flow/codex package
+        // Use a variable to prevent TypeScript from statically resolving the optional module
+        const codexModuleId = '@claude-flow/codex';
         const resolutionStrategies = [
             // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import('@claude-flow/codex')).CodexInitializer,
+            async () => (await import(codexModuleId)).CodexInitializer,
             // Strategy 2: Project node_modules (works if installed in user's project)
             async () => {
                 const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');

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

@@ -430,7 +430,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 ddd: { progress: 0, modules: 0, totalFiles: 0, totalLines: 0 },
                 swarm: { activeAgents: 0, maxAgents: 15, topology: 'hierarchical-mesh' },
                 learning: { status: 'READY', patternsLearned: 0, sessionsCompleted: 0 },
-                _note: 'Metrics will update as you use Claude Flow'
+                _note: 'Metrics will update as you use Ruflo'
             };
             fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
             result.created.push('.claude-flow/metrics/v3-progress.json');
@@ -462,7 +462,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 routing: { accuracy: 0, decisions: 0 },
                 patterns: { shortTerm: 0, longTerm: 0, quality: 0 },
                 sessions: { total: 0, current: null },
-                _note: 'Intelligence grows as you use Claude Flow'
+                _note: 'Intelligence grows as you use Ruflo'
             };
             fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
             result.created.push('.claude-flow/metrics/learning.json');
@@ -1129,7 +1129,7 @@ async function writeInitialMetrics(targetDir, options, result) {
                 patternsLearned: 0,
                 sessionsCompleted: 0
             },
-            _note: 'Metrics will update as you use Claude Flow. Run: npx @claude-flow/cli@latest daemon start'
+            _note: 'Metrics will update as you use Ruflo. Run: npx ruflo@latest daemon start'
         };
         fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf-8');
         result.created.files.push('.claude-flow/metrics/v3-progress.json');
@@ -1176,7 +1176,7 @@ async function writeInitialMetrics(targetDir, options, result) {
                 total: 0,
                 current: null
             },
-            _note: 'Intelligence grows as you use Claude Flow'
+            _note: 'Intelligence grows as you use Ruflo'
         };
         fs.writeFileSync(learningPath, JSON.stringify(learning, null, 2), 'utf-8');
         result.created.files.push('.claude-flow/metrics/learning.json');
@@ -1197,7 +1197,7 @@ async function writeInitialMetrics(targetDir, options, result) {
     }
 }
 /**
- * Write CAPABILITIES.md - comprehensive overview of all Claude Flow features
+ * Write CAPABILITIES.md - comprehensive overview of all Ruflo features
  */
 async function writeCapabilitiesDoc(targetDir, options, result) {
     const capabilitiesPath = path.join(targetDir, '.claude-flow', 'CAPABILITIES.md');
@@ -1556,8 +1556,8 @@ npx @claude-flow/cli@latest hive-mind consensus --propose "task"
 
 ### MCP Server Setup
 \`\`\`bash
-# Add Claude Flow MCP
-claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
+# Add Ruflo MCP
+claude mcp add ruflo -- npx -y ruflo@latest
 
 # Optional servers
 claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start
@@ -1571,24 +1571,24 @@ claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start
 ### Essential Commands
 \`\`\`bash
 # Setup
-npx @claude-flow/cli@latest init --wizard
-npx @claude-flow/cli@latest daemon start
-npx @claude-flow/cli@latest doctor --fix
+npx ruflo@latest init --wizard
+npx ruflo@latest daemon start
+npx ruflo@latest doctor --fix
 
 # Swarm
-npx @claude-flow/cli@latest swarm init --topology hierarchical --max-agents 8
-npx @claude-flow/cli@latest swarm status
+npx ruflo@latest swarm init --topology hierarchical --max-agents 8
+npx ruflo@latest swarm status
 
 # Agents
-npx @claude-flow/cli@latest agent spawn -t coder
-npx @claude-flow/cli@latest agent list
+npx ruflo@latest agent spawn -t coder
+npx ruflo@latest agent list
 
 # Memory
-npx @claude-flow/cli@latest memory search --query "patterns"
+npx ruflo@latest memory search --query "patterns"
 
 # Hooks
-npx @claude-flow/cli@latest hooks pre-task --description "task"
-npx @claude-flow/cli@latest hooks worker dispatch --trigger optimize
+npx ruflo@latest hooks pre-task --description "task"
+npx ruflo@latest hooks worker dispatch --trigger optimize
 \`\`\`
 
 ### File Structure

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

@@ -8,12 +8,12 @@ import { generateStatuslineScript, generateStatuslineHook } from './statusline-g
  */
 export function generatePreCommitHook() {
     return `#!/bin/bash
-# Claude Flow Pre-Commit Hook
+# Ruflo Pre-Commit Hook
 # Validates code quality before commit
 
 set -e
 
-echo "🔍 Running Claude Flow pre-commit checks..."
+echo "🔍 Running Ruflo pre-commit checks..."
 
 # Get staged files
 STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
@@ -40,7 +40,7 @@ echo "✅ Pre-commit checks complete"
  */
 export function generatePostCommitHook() {
     return `#!/bin/bash
-# Claude Flow Post-Commit Hook
+# Ruflo Post-Commit Hook
 # Records commit metrics and trains patterns
 
 COMMIT_HASH=$(git rev-parse HEAD)
@@ -48,8 +48,8 @@ COMMIT_MSG=$(git log -1 --pretty=%B)
 
 echo "📊 Recording commit metrics..."
 
-# Notify claude-flow of commit
-npx @claude-flow/cli hooks notify \\
+# Notify ruflo of commit
+npx ruflo@latest hooks notify \\
   --message "Commit: $COMMIT_MSG" \\
   --level info \\
   --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true
@@ -63,7 +63,7 @@ echo "✅ Commit recorded"
 export function generateSessionManager() {
     return `#!/usr/bin/env node
 /**
- * Claude Flow Session Manager
+ * Ruflo Session Manager
  * Handles session lifecycle: start, restore, end
  */
 
@@ -196,7 +196,7 @@ module.exports = commands;
 export function generateAgentRouter() {
     return `#!/usr/bin/env node
 /**
- * Claude Flow Agent Router
+ * Ruflo Agent Router
  * Routes tasks to optimal agents based on learned patterns
  */
 
@@ -268,7 +268,7 @@ module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS };
 export function generateMemoryHelper() {
     return `#!/usr/bin/env node
 /**
- * Claude Flow Memory Helper
+ * Ruflo Memory Helper
  * Simple key-value memory for cross-session context
  */
 
@@ -361,7 +361,7 @@ export function generateHookHandler() {
     const lines = [
         '#!/usr/bin/env node',
         '/**',
-        ' * Claude Flow Hook Handler (Cross-Platform)',
+        ' * Ruflo Hook Handler (Cross-Platform)',
         ' * Dispatches hook events to the appropriate helper modules.',
         ' */',
         '',
@@ -1026,7 +1026,7 @@ PowerShell -ExecutionPolicy Bypass -File "%~dp0daemon-manager.ps1" %*
 export function generateCrossPlatformSessionManager() {
     return `#!/usr/bin/env node
 /**
- * Claude Flow Cross-Platform Session Manager
+ * Ruflo Cross-Platform Session Manager
  * Works on Windows, macOS, and Linux
  */
 

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

@@ -3,7 +3,7 @@
  * Provides intelligent hooks functionality via MCP protocol
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync } from 'fs';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -121,7 +121,88 @@ function generateSimpleEmbedding(text, dimension = 384) {
     }
     return embedding;
 }
-// Task patterns used by both native and pure-JS routers
+// ── Runtime routing outcome persistence ──────────────────────────────
+// Closes the learning loop: post-task records outcomes → route loads them.
+const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.claude-flow/routing-outcomes.json');
+const ROUTING_STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+    'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can',
+    'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
+    'before', 'after', 'above', 'below', 'between', 'under', 'again', 'further', 'then', 'once',
+    'it', 'its', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'she', 'they', 'them', 'and', 'but', 'or', 'nor', 'not', 'no', 'so', 'if', 'when', 'than',
+    'very', 'just', 'also', 'only', 'both', 'each', 'all', 'any', 'few', 'more', 'most', 'other',
+    'some', 'such', 'same', 'new', 'now', 'here', 'there', 'where', 'how', 'what', 'which', 'who',
+]);
+function extractKeywords(text) {
+    if (!text)
+        return [];
+    return text.toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !ROUTING_STOPWORDS.has(w));
+}
+function loadRoutingOutcomes() {
+    try {
+        if (existsSync(ROUTING_OUTCOMES_PATH)) {
+            const data = JSON.parse(readFileSync(ROUTING_OUTCOMES_PATH, 'utf-8'));
+            return data.outcomes || [];
+        }
+    }
+    catch { /* corrupt file, start fresh */ }
+    return [];
+}
+function saveRoutingOutcomes(outcomes) {
+    try {
+        const dir = dirname(ROUTING_OUTCOMES_PATH);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        // Cap at 500 entries to bound file size
+        const capped = outcomes.slice(-500);
+        writeFileSync(ROUTING_OUTCOMES_PATH, JSON.stringify({ outcomes: capped }, null, 2));
+    }
+    catch { /* non-critical */ }
+}
+/**
+ * Build learned routing patterns from successful task outcomes.
+ * Returns patterns in the same shape as TASK_PATTERNS so they can be
+ * merged into both the native HNSW and pure-JS semantic routers.
+ */
+function loadLearnedPatterns() {
+    const outcomes = loadRoutingOutcomes();
+    const byAgent = {};
+    for (const o of outcomes) {
+        if (!o.success || !o.agent || !o.keywords?.length)
+            continue;
+        if (!byAgent[o.agent])
+            byAgent[o.agent] = new Set();
+        for (const kw of o.keywords)
+            byAgent[o.agent].add(kw);
+    }
+    const patterns = {};
+    for (const [agent, kwSet] of Object.entries(byAgent)) {
+        patterns[`learned-${agent}`] = {
+            keywords: [...kwSet].slice(0, 50),
+            agents: [agent],
+        };
+    }
+    return patterns;
+}
+/**
+ * Merge static TASK_PATTERNS with runtime-learned patterns.
+ * Static patterns take precedence (learned patterns won't overwrite them).
+ */
+function getMergedTaskPatterns() {
+    const merged = { ...TASK_PATTERNS };
+    const learned = loadLearnedPatterns();
+    for (const [key, pattern] of Object.entries(learned)) {
+        if (!merged[key]) {
+            merged[key] = pattern;
+        }
+    }
+    return merged;
+}
+// ── Static task patterns (used by both native and pure-JS routers) ───
 const TASK_PATTERNS = {
     'security-task': {
         keywords: ['authentication', 'security', 'auth', 'password', 'encryption', 'vulnerability', 'cve', 'audit'],
@@ -198,8 +279,8 @@ async function getSemanticRouter() {
                 hnswEfConstruction: 200,
                 hnswEfSearch: 100,
             });
-            // Initialize with task patterns
-            for (const [patternName, { keywords }] of Object.entries(TASK_PATTERNS)) {
+            // Initialize with static + runtime-learned task patterns
+            for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
                 for (const keyword of keywords) {
                     const embedding = generateSimpleEmbedding(keyword);
                     db.insert(`${patternName}:${keyword}`, embedding);
@@ -220,7 +301,7 @@ async function getSemanticRouter() {
     try {
         const { SemanticRouter } = await import('../ruvector/semantic-router.js');
         semanticRouter = new SemanticRouter({ dimension: 384 });
-        for (const [patternName, { keywords, agents }] of Object.entries(TASK_PATTERNS)) {
+        for (const [patternName, { keywords, agents }] of Object.entries(getMergedTaskPatterns())) {
             const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
             semanticRouter.addIntentWithEmbeddings(patternName, embeddings, { agents, keywords });
             // Cache embeddings for keywords
@@ -414,11 +495,32 @@ function suggestAgentsForFile(filePath) {
 }
 function suggestAgentsForTask(task) {
     const taskLower = task.toLowerCase();
+    // Check static keyword patterns first
     for (const [pattern, result] of Object.entries(KEYWORD_PATTERNS)) {
         if (taskLower.includes(pattern)) {
             return result;
         }
     }
+    // Check runtime-learned patterns from successful task outcomes
+    const taskKeywords = extractKeywords(task);
+    if (taskKeywords.length > 0) {
+        const outcomes = loadRoutingOutcomes();
+        let bestAgent = '';
+        let bestOverlap = 0;
+        for (const outcome of outcomes) {
+            if (!outcome.success || !outcome.agent || !outcome.keywords?.length)
+                continue;
+            const overlap = taskKeywords.filter(kw => outcome.keywords.includes(kw)).length;
+            if (overlap > bestOverlap) {
+                bestOverlap = overlap;
+                bestAgent = outcome.agent;
+            }
+        }
+        // Require at least 2 keyword overlap to prevent false positives
+        if (bestAgent && bestOverlap >= 2) {
+            return { agents: [bestAgent], confidence: Math.min(0.6 + bestOverlap * 0.05, 0.85) };
+        }
+    }
     // Default fallback
     return { agents: ['coder', 'researcher', 'tester'], confidence: 0.7 };
 }
@@ -674,13 +776,16 @@ export const hooksRoute = {
                 routingMethod = 'semantic-native';
                 backendInfo = 'native VectorDb (HNSW)';
                 // Convert results to semantic format
+                const mergedPatterns = getMergedTaskPatterns();
                 semanticResult = results.map((r) => {
                     const [patternName] = r.id.split(':');
-                    const pattern = TASK_PATTERNS[patternName];
+                    const pattern = mergedPatterns[patternName];
                     return {
                         intent: patternName,
                         score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
-                        metadata: { agents: pattern?.agents || ['coder'] },
+                        metadata: {
+                            agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
+                        },
                     };
                 });
             }
@@ -941,6 +1046,8 @@ export const hooksPostTask = {
             success: { type: 'boolean', description: 'Whether task was successful' },
             agent: { type: 'string', description: 'Agent that completed the task' },
             quality: { type: 'number', description: 'Quality score (0-1)' },
+            task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
+            storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
         },
         required: ['taskId'],
     },
@@ -979,6 +1086,41 @@ export const hooksPostTask = {
         catch {
             // Non-fatal
         }
+        // Persist routing outcome for runtime learning (file-based, always reliable)
+        const taskText = params.task || '';
+        const outcomeKeywords = extractKeywords(taskText);
+        let outcomePersisted = false;
+        if (taskText && agent && agent.length <= 100 && /^[a-zA-Z0-9_-]+$/.test(agent)) {
+            try {
+                const outcomes = loadRoutingOutcomes();
+                outcomes.push({
+                    task: taskText,
+                    agent,
+                    success,
+                    quality,
+                    keywords: outcomeKeywords,
+                    timestamp: new Date().toISOString(),
+                });
+                saveRoutingOutcomes(outcomes);
+                outcomePersisted = true;
+            }
+            catch { /* non-critical */ }
+        }
+        // Optionally store in memory DB for cross-session vector retrieval
+        if (params.storeDecisions && taskText && agent) {
+            try {
+                const storeFn = await getRealStoreFunction();
+                if (storeFn) {
+                    await storeFn({
+                        key: `routing-decision:${taskId}`,
+                        namespace: 'patterns',
+                        value: JSON.stringify({ task: taskText, agent, success, quality, keywords: outcomeKeywords }),
+                        tags: ['routing-decision'],
+                    });
+                }
+            }
+            catch { /* non-critical */ }
+        }
         const duration = Date.now() - startTime;
         return {
             taskId,
@@ -989,6 +1131,7 @@ export const hooksPostTask = {
                 newPatterns: success ? 1 : 0,
                 trajectoryId: `traj-${Date.now()}`,
                 controller: feedbackResult?.controller || 'none',
+                outcomePersisted,
             },
             quality,
             feedback: feedbackResult ? {

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

@@ -6,7 +6,7 @@ export { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, } fr
 export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS, LOCAL_WORKER_TYPES, LOCAL_WORKER_CONFIGS, ALL_WORKER_CONFIGS, isHeadlessWorker, isLocalWorker, getModelId, getWorkerConfig, type HeadlessWorkerType, type LocalWorkerType, type HeadlessWorkerConfig, type HeadlessExecutionResult, type HeadlessExecutorConfig, type HeadlessOptions, type PoolStatus, type SandboxMode, type ModelType, type OutputFormat, type ExecutionMode, type WorkerPriority, type WorkerConfig, } from './headless-worker-executor.js';
 export { ContainerWorkerPool, type ContainerInfo, type ContainerPoolConfig, type ContainerExecutionOptions, type ContainerPoolStatus, type ContainerState, } from './container-worker-pool.js';
 export { WorkerQueue, type QueueTask, type WorkerQueueConfig, type QueueStats, type WorkerRegistration, type TaskStatus, } from './worker-queue.js';
-export type { default as WorkerDaemonType } from './worker-daemon.js';
+export type { default as WorkerDaemonType, DaemonConfig } from './worker-daemon.js';
 export type { default as HeadlessWorkerExecutorType } from './headless-worker-executor.js';
 export type { default as ContainerWorkerPoolType } from './container-worker-pool.js';
 export type { default as WorkerQueueType } from './worker-queue.js';

package/v3/@claude-flow/cli/dist/src/services/ruvector-training.js

@@ -13,6 +13,14 @@
  *
  * Created with ❤️ by ruv.io
  */
+/**
+ * ESM/CJS interop helper — handles `.default` for CJS modules.
+ * Uses `'default' in mod` check which is safer than `mod.default || mod`.
+ */
+async function importWithInterop(packageName) {
+    const mod = await import(packageName);
+    return ('default' in mod) ? mod.default : mod;
+}
 // Lazy-loaded WASM modules
 let microLoRA = null;
 let scopedLoRA = null;
@@ -252,7 +260,7 @@ export async function initializeTraining(config = {}) {
     }
     // --- Attention mechanisms (optional, independent of WASM) ---
     try {
-        const attention = await import('@ruvector/attention');
+        const attention = await importWithInterop('@ruvector/attention');
         if (config.useFlashAttention !== false) {
             flashAttention = new attention.FlashAttention(dim, 64);
             features.push('FlashAttention');
@@ -289,9 +297,8 @@ export async function initializeTraining(config = {}) {
     // --- SONA (optional, backward compatible) ---
     if (config.useSona !== false) {
         try {
-            const sona = await import('@ruvector/sona');
+            const sona = await importWithInterop('@ruvector/sona');
             const sonaRank = config.sonaRank || 4;
-            // @ts-expect-error - SonaEngine accepts 4 positional args but types say 1
             sonaEngine = new sona.SonaEngine(dim, sonaRank, alpha, lr);
             sonaAvailable = true;
             features.push(`SONA (${dim}-dim, rank-${sonaRank}, 624k learn/s)`);
@@ -473,7 +480,7 @@ export function mineHardNegatives(anchor, candidates) {
  * Benchmark the training system
  */
 export async function benchmarkTraining(dim, iterations) {
-    const attention = await import('@ruvector/attention');
+    const attention = await importWithInterop('@ruvector/attention');
     lastBenchmark = attention.benchmarkAttention(dim || 256, 100, iterations || 1000);
     return lastBenchmark ?? [];
 }

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

@@ -44,7 +44,7 @@ interface DaemonStatus {
     workers: Map<WorkerType, WorkerState>;
     config: DaemonConfig;
 }
-interface DaemonConfig {
+export interface DaemonConfig {
     autoStart: boolean;
     logDir: string;
     stateFile: string;
@@ -70,6 +70,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private pendingWorkers;
     private headlessExecutor;
     private headlessAvailable;
+    private originalConfig?;
     constructor(projectRoot: string, config?: Partial<DaemonConfig>);
     /**
      * Initialize headless executor if Claude Code is available
@@ -83,6 +84,20 @@ export declare class WorkerDaemon extends EventEmitter {
      * Get headless executor instance
      */
     getHeadlessExecutor(): HeadlessWorkerExecutor | null;
+    /**
+     * Detect effective CPU count for the current environment.
+     *
+     * Inside Docker / K8s containers, os.cpus().length reports the HOST cpu
+     * count, not the container limit (Node.js #28762 — wontfix).  We read
+     * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
+     * meaningful under resource-limited containers.
+     */
+    static getEffectiveCpuCount(): number;
+    /**
+     * Read daemon-specific config from .claude-flow/config.json
+     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
+     */
+    private readDaemonConfigFromFile;
     /**
      * Setup graceful shutdown handlers
      */
@@ -93,6 +108,12 @@ export declare class WorkerDaemon extends EventEmitter {
     private canRunWorker;
     /**
      * Process pending workers queue
+     *
+     * When executeWorkerWithConcurrencyControl defers a worker (returns null),
+     * we break immediately to avoid a busy-wait loop — the deferred worker is
+     * already back on the pendingWorkers queue by that point. If no workers are
+     * currently running when we break, we schedule a backoff retry so the queue
+     * does not get permanently stuck.
      */
     private processPendingWorkers;
     private initializeWorkerStates;
@@ -194,11 +215,11 @@ export declare class WorkerDaemon extends EventEmitter {
 /**
  * Get or create daemon instance
  */
-export declare function getDaemon(projectRoot?: string): WorkerDaemon;
+export declare function getDaemon(projectRoot?: string, config?: Partial<DaemonConfig>): WorkerDaemon;
 /**
  * Start daemon (for use in session-start hook)
  */
-export declare function startDaemon(projectRoot: string): Promise<WorkerDaemon>;
+export declare function startDaemon(projectRoot: string, config?: Partial<DaemonConfig>): Promise<WorkerDaemon>;
 /**
  * Stop daemon
  */

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

@@ -11,6 +11,7 @@
  */
 import { EventEmitter } from 'events';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { cpus } from 'os';
 import { join } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
 // Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
@@ -40,19 +41,35 @@ export class WorkerDaemon extends EventEmitter {
     // Headless execution support
     headlessExecutor = null;
     headlessAvailable = false;
+    // Preserve the original constructor config so we can detect explicit overrides
+    // during state restoration (R1: constructor config takes priority over stale state)
+    originalConfig;
     constructor(projectRoot, config) {
         super();
         this.projectRoot = projectRoot;
+        this.originalConfig = config;
         const claudeFlowDir = join(projectRoot, '.claude-flow');
+        // Read daemon config from .claude-flow/config.json (Layer B)
+        const fileConfig = this.readDaemonConfigFromFile(claudeFlowDir);
+        // CPU-proportional smart default instead of hardcoded 2.0
+        const cpuCount = WorkerDaemon.getEffectiveCpuCount();
+        const smartMaxCpuLoad = Math.max(cpuCount * 0.8, 2.0); // Floor of 2.0 for single-CPU machines
+        // Platform-aware default: macOS os.freemem() excludes reclaimable file cache,
+        // so reported "free" is much lower than actually available memory.
+        // Linux reports available memory (including reclaimable cache) more accurately.
+        const defaultMinFreeMemory = process.platform === 'darwin' ? 5 : 10;
+        // Priority: constructor arg > config.json > smart default
+        // For resourceThresholds, merge field-by-field so partial overrides
+        // (e.g. only --max-cpu-load) still pick up defaults for other fields.
         this.config = {
-            autoStart: config?.autoStart ?? false, // P1 fix: Default to false for explicit consent
+            autoStart: config?.autoStart ?? fileConfig.autoStart ?? false,
             logDir: config?.logDir ?? join(claudeFlowDir, 'logs'),
             stateFile: config?.stateFile ?? join(claudeFlowDir, 'daemon-state.json'),
-            maxConcurrent: config?.maxConcurrent ?? 2, // P0 fix: Limit concurrent workers
-            workerTimeoutMs: config?.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
-            resourceThresholds: config?.resourceThresholds ?? {
-                maxCpuLoad: 2.0,
-                minFreeMemoryPercent: 20,
+            maxConcurrent: config?.maxConcurrent ?? fileConfig.maxConcurrent ?? 2,
+            workerTimeoutMs: config?.workerTimeoutMs ?? fileConfig.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
+            resourceThresholds: {
+                maxCpuLoad: config?.resourceThresholds?.maxCpuLoad ?? fileConfig.maxCpuLoad ?? smartMaxCpuLoad,
+                minFreeMemoryPercent: config?.resourceThresholds?.minFreeMemoryPercent ?? fileConfig.minFreeMemoryPercent ?? defaultMinFreeMemory,
             },
             workers: config?.workers ?? DEFAULT_WORKERS,
         };
@@ -118,6 +135,66 @@ export class WorkerDaemon extends EventEmitter {
     getHeadlessExecutor() {
         return this.headlessExecutor;
     }
+    /**
+     * Detect effective CPU count for the current environment.
+     *
+     * Inside Docker / K8s containers, os.cpus().length reports the HOST cpu
+     * count, not the container limit (Node.js #28762 — wontfix).  We read
+     * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
+     * meaningful under resource-limited containers.
+     */
+    static getEffectiveCpuCount() {
+        // 1. Try cgroup v2: /sys/fs/cgroup/cpu.max
+        try {
+            const cpuMax = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim();
+            const [quotaStr, periodStr] = cpuMax.split(' ');
+            if (quotaStr !== 'max') {
+                const quota = parseInt(quotaStr, 10);
+                const period = parseInt(periodStr, 10);
+                if (quota > 0 && period > 0)
+                    return Math.ceil(quota / period);
+            }
+        }
+        catch { /* not in cgroup v2 */ }
+        // 2. Try cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us
+        try {
+            const quota = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8').trim(), 10);
+            const period = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8').trim(), 10);
+            if (quota > 0 && period > 0)
+                return Math.ceil(quota / period);
+        }
+        catch { /* not in cgroup v1 */ }
+        // 3. Fallback to os.cpus().length
+        return cpus().length || 1;
+    }
+    /**
+     * Read daemon-specific config from .claude-flow/config.json
+     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
+     */
+    readDaemonConfigFromFile(claudeFlowDir) {
+        const configPath = join(claudeFlowDir, 'config.json');
+        if (!existsSync(configPath))
+            return {};
+        try {
+            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            // Support both flat keys at root and nested under scopes.project
+            const cfg = raw?.scopes?.project ?? raw;
+            const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
+            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'];
+            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,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
     /**
      * Setup graceful shutdown handlers
      */
@@ -150,13 +227,30 @@ export class WorkerDaemon extends EventEmitter {
     }
     /**
      * Process pending workers queue
+     *
+     * When executeWorkerWithConcurrencyControl defers a worker (returns null),
+     * we break immediately to avoid a busy-wait loop — the deferred worker is
+     * already back on the pendingWorkers queue by that point. If no workers are
+     * currently running when we break, we schedule a backoff retry so the queue
+     * does not get permanently stuck.
      */
     async processPendingWorkers() {
         while (this.pendingWorkers.length > 0 && this.runningWorkers.size < this.config.maxConcurrent) {
             const workerType = this.pendingWorkers.shift();
             const workerConfig = this.config.workers.find(w => w.type === workerType);
             if (workerConfig) {
-                await this.executeWorkerWithConcurrencyControl(workerConfig);
+                const result = await this.executeWorkerWithConcurrencyControl(workerConfig);
+                if (result === null) {
+                    // Worker was deferred (resource pressure or concurrency limit).
+                    // Break to avoid tight-looping — the next executeWorker() completion
+                    // will call processPendingWorkers() again via the finally block.
+                    if (this.runningWorkers.size === 0) {
+                        // No workers running means nobody will trigger the finally-block
+                        // callback, so schedule a backoff retry to avoid a stuck queue.
+                        setTimeout(() => this.processPendingWorkers(), 30_000).unref();
+                    }
+                    break;
+                }
             }
         }
     }
@@ -175,6 +269,23 @@ export class WorkerDaemon extends EventEmitter {
                         }
                     }
                 }
+                // Restore resourceThresholds, maxConcurrent, workerTimeoutMs from saved state
+                // Only restore if valid numeric values within sane ranges
+                if (saved.config?.resourceThresholds && !this.originalConfig?.resourceThresholds) {
+                    const rt = saved.config.resourceThresholds;
+                    if (typeof rt.maxCpuLoad === 'number' && rt.maxCpuLoad > 0 && rt.maxCpuLoad < 1000) {
+                        this.config.resourceThresholds.maxCpuLoad = rt.maxCpuLoad;
+                    }
+                    if (typeof rt.minFreeMemoryPercent === 'number' && rt.minFreeMemoryPercent >= 0 && rt.minFreeMemoryPercent <= 100) {
+                        this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
+                    }
+                }
+                if (typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
+                    this.config.maxConcurrent = saved.config.maxConcurrent;
+                }
+                if (typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
+                    this.config.workerTimeoutMs = saved.config.workerTimeoutMs;
+                }
                 // Restore worker runtime states (runCount, successCount, etc.)
                 if (saved.workers) {
                     for (const [type, state] of Object.entries(saved.workers)) {
@@ -228,7 +339,7 @@ export class WorkerDaemon extends EventEmitter {
         }
         // Save state
         this.saveState();
-        this.log('info', `Daemon started with ${this.config.workers.filter(w => w.enabled).length} workers`);
+        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}%)`);
     }
     /**
      * Stop the daemon and all workers
@@ -755,9 +866,9 @@ let daemonInstance = null;
 /**
  * Get or create daemon instance
  */
-export function getDaemon(projectRoot) {
+export function getDaemon(projectRoot, config) {
     if (!daemonInstance && projectRoot) {
-        daemonInstance = new WorkerDaemon(projectRoot);
+        daemonInstance = new WorkerDaemon(projectRoot, config);
     }
     if (!daemonInstance) {
         throw new Error('Daemon not initialized. Provide projectRoot on first call.');
@@ -767,8 +878,8 @@ export function getDaemon(projectRoot) {
 /**
  * Start daemon (for use in session-start hook)
  */
-export async function startDaemon(projectRoot) {
-    const daemon = getDaemon(projectRoot);
+export async function startDaemon(projectRoot, config) {
+    const daemon = getDaemon(projectRoot, config);
     await daemon.start();
     return daemon;
 }

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

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