claude-flow 3.5.23 → 3.5.25

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

@@ -1,82 +1,212 @@
 /**
  * Swarm MCP Tools for CLI
  *
- * Tool definitions for swarm coordination.
+ * Tool definitions for swarm coordination with file-based state persistence.
+ * Replaces previous stub implementations with real state tracking.
  */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Swarm state persistence
+const SWARM_DIR = '.claude-flow/swarm';
+const SWARM_STATE_FILE = 'swarm-state.json';
+function getSwarmDir() {
+    return join(process.cwd(), SWARM_DIR);
+}
+function getSwarmStatePath() {
+    return join(getSwarmDir(), SWARM_STATE_FILE);
+}
+function ensureSwarmDir() {
+    const dir = getSwarmDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
+function loadSwarmStore() {
+    try {
+        const path = getSwarmStatePath();
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+    }
+    catch { /* return default */ }
+    return { swarms: {}, version: '3.0.0' };
+}
+function saveSwarmStore(store) {
+    ensureSwarmDir();
+    writeFileSync(getSwarmStatePath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+// Input validation
+const VALID_TOPOLOGIES = new Set([
+    'hierarchical', 'mesh', 'hierarchical-mesh', 'ring', 'star', 'hybrid', 'adaptive',
+]);
 export const swarmTools = [
     {
         name: 'swarm_init',
-        description: 'Initialize a swarm',
+        description: 'Initialize a swarm with persistent state tracking',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                topology: { type: 'string', description: 'Swarm topology type' },
-                maxAgents: { type: 'number', description: 'Maximum number of agents' },
-                config: { type: 'object', description: 'Swarm configuration' },
+                topology: { type: 'string', description: 'Swarm topology type (hierarchical, mesh, hierarchical-mesh, ring, star, hybrid, adaptive)' },
+                maxAgents: { type: 'number', description: 'Maximum number of agents (1-50)' },
+                strategy: { type: 'string', description: 'Agent strategy (specialized, balanced, adaptive)' },
+                config: { type: 'object', description: 'Additional swarm configuration' },
             },
         },
         handler: async (input) => {
             const topology = input.topology || 'hierarchical-mesh';
-            const maxAgents = input.maxAgents || 15;
+            const maxAgents = Math.min(Math.max(input.maxAgents || 15, 1), 50);
+            const strategy = input.strategy || 'specialized';
             const config = (input.config || {});
-            return {
-                success: true,
-                swarmId: `swarm-${Date.now()}`,
+            if (!VALID_TOPOLOGIES.has(topology)) {
+                return {
+                    success: false,
+                    error: `Invalid topology: ${topology}. Valid: ${[...VALID_TOPOLOGIES].join(', ')}`,
+                };
+            }
+            const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const now = new Date().toISOString();
+            const swarmState = {
+                swarmId,
                 topology,
-                initializedAt: new Date().toISOString(),
+                maxAgents,
+                status: 'running',
+                agents: [],
+                tasks: [],
                 config: {
                     topology,
                     maxAgents,
-                    currentAgents: 0,
+                    strategy,
                     communicationProtocol: config.communicationProtocol || 'message-bus',
                     autoScaling: config.autoScaling ?? true,
                     consensusMechanism: config.consensusMechanism || 'majority',
                 },
+                createdAt: now,
+                updatedAt: now,
+            };
+            const store = loadSwarmStore();
+            store.swarms[swarmId] = swarmState;
+            saveSwarmStore(store);
+            return {
+                success: true,
+                swarmId,
+                topology,
+                strategy,
+                maxAgents,
+                initializedAt: now,
+                config: swarmState.config,
+                persisted: true,
             };
         },
     },
     {
         name: 'swarm_status',
-        description: 'Get swarm status',
+        description: 'Get swarm status from persistent state',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                swarmId: { type: 'string', description: 'Swarm ID' },
+                swarmId: { type: 'string', description: 'Swarm ID (omit for most recent)' },
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            if (swarmId && store.swarms[swarmId]) {
+                const swarm = store.swarms[swarmId];
+                return {
+                    swarmId: swarm.swarmId,
+                    status: swarm.status,
+                    topology: swarm.topology,
+                    maxAgents: swarm.maxAgents,
+                    agentCount: swarm.agents.length,
+                    taskCount: swarm.tasks.length,
+                    config: swarm.config,
+                    createdAt: swarm.createdAt,
+                    updatedAt: swarm.updatedAt,
+                };
+            }
+            // Return most recent swarm if no ID specified
+            const swarmIds = Object.keys(store.swarms);
+            if (swarmIds.length === 0) {
+                return {
+                    status: 'no_swarm',
+                    message: 'No active swarms. Use swarm_init to create one.',
+                    totalSwarms: 0,
+                };
+            }
+            const latest = swarmIds
+                .map(id => store.swarms[id])
+                .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime())[0];
             return {
-                swarmId: input.swarmId,
-                status: 'running',
-                agentCount: 0,
-                taskCount: 0,
+                swarmId: latest.swarmId,
+                status: latest.status,
+                topology: latest.topology,
+                maxAgents: latest.maxAgents,
+                agentCount: latest.agents.length,
+                taskCount: latest.tasks.length,
+                config: latest.config,
+                createdAt: latest.createdAt,
+                updatedAt: latest.updatedAt,
+                totalSwarms: swarmIds.length,
             };
         },
     },
     {
         name: 'swarm_shutdown',
-        description: 'Shutdown a swarm',
+        description: 'Shutdown a swarm and update persistent state',
         category: 'swarm',
         inputSchema: {
             type: 'object',
             properties: {
-                swarmId: { type: 'string', description: 'Swarm ID' },
-                graceful: { type: 'boolean', description: 'Graceful shutdown' },
+                swarmId: { type: 'string', description: 'Swarm ID to shutdown' },
+                graceful: { type: 'boolean', description: 'Graceful shutdown (default: true)' },
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            // Find the swarm
+            let target;
+            if (swarmId && store.swarms[swarmId]) {
+                target = store.swarms[swarmId];
+            }
+            else {
+                // Shutdown most recent running swarm
+                const running = Object.values(store.swarms)
+                    .filter(s => s.status === 'running')
+                    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+                target = running[0];
+            }
+            if (!target) {
+                return {
+                    success: false,
+                    error: swarmId ? `Swarm ${swarmId} not found` : 'No running swarms to shutdown',
+                };
+            }
+            if (target.status === 'terminated') {
+                return {
+                    success: false,
+                    swarmId: target.swarmId,
+                    error: 'Swarm already terminated',
+                };
+            }
+            target.status = 'terminated';
+            target.updatedAt = new Date().toISOString();
+            saveSwarmStore(store);
             return {
                 success: true,
-                swarmId: input.swarmId,
+                swarmId: target.swarmId,
                 terminated: true,
+                graceful: input.graceful ?? true,
+                agentsTerminated: target.agents.length,
+                terminatedAt: target.updatedAt,
             };
         },
     },
     {
         name: 'swarm_health',
-        description: 'Check swarm health status',
+        description: 'Check swarm health status with real state inspection',
         category: 'swarm',
         inputSchema: {
             type: 'object',
@@ -85,15 +215,71 @@ export const swarmTools = [
             },
         },
         handler: async (input) => {
+            const store = loadSwarmStore();
+            const swarmId = input.swarmId;
+            // Find the swarm
+            let target;
+            if (swarmId) {
+                target = store.swarms[swarmId];
+                if (!target) {
+                    return {
+                        status: 'not_found',
+                        healthy: false,
+                        checks: [
+                            { name: 'swarm_exists', status: 'fail', message: `Swarm ${swarmId} not found` },
+                        ],
+                        checkedAt: new Date().toISOString(),
+                    };
+                }
+            }
+            else {
+                const running = Object.values(store.swarms)
+                    .filter(s => s.status === 'running')
+                    .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+                target = running[0];
+            }
+            if (!target) {
+                return {
+                    status: 'no_swarm',
+                    healthy: false,
+                    checks: [
+                        { name: 'swarm_exists', status: 'fail', message: 'No active swarm found' },
+                    ],
+                    checkedAt: new Date().toISOString(),
+                };
+            }
+            const isRunning = target.status === 'running';
+            const stateFileExists = existsSync(getSwarmStatePath());
+            const checks = [
+                {
+                    name: 'coordinator',
+                    status: isRunning ? 'ok' : 'warn',
+                    message: isRunning ? 'Coordinator active' : `Swarm status: ${target.status}`,
+                },
+                {
+                    name: 'agents',
+                    status: target.agents.length > 0 ? 'ok' : 'info',
+                    message: `${target.agents.length} agents registered (max: ${target.maxAgents})`,
+                },
+                {
+                    name: 'persistence',
+                    status: stateFileExists ? 'ok' : 'warn',
+                    message: stateFileExists ? 'State file persisted' : 'State file missing',
+                },
+                {
+                    name: 'topology',
+                    status: 'ok',
+                    message: `Topology: ${target.topology}`,
+                },
+            ];
+            const healthy = isRunning && stateFileExists;
             return {
-                status: 'healthy',
-                swarmId: input.swarmId || 'default',
-                checks: [
-                    { name: 'coordinator', status: 'ok', message: 'Coordinator responding' },
-                    { name: 'agents', status: 'ok', message: 'Agent pool healthy' },
-                    { name: 'memory', status: 'ok', message: 'Memory backend connected' },
-                    { name: 'messaging', status: 'ok', message: 'Message bus active' },
-                ],
+                status: healthy ? 'healthy' : 'degraded',
+                healthy,
+                swarmId: target.swarmId,
+                topology: target.topology,
+                agentCount: target.agents.length,
+                checks,
                 checkedAt: new Date().toISOString(),
             };
         },

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;
 }