@claude-flow/cli 3.61.0 → 3.62.0

package/dist/src/services/headless-worker-executor.js

@@ -584,7 +584,12 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             return false;
         }
         clearTimeout(entry.timeout);
-        this.killEntryTree(entry.process, 'SIGTERM');
+        if (entry.abort) {
+            entry.abort();
+        }
+        else {
+            this.killEntryTree(entry.process, 'SIGTERM');
+        }
         this.processPool.delete(executionId);
         this.emit('cancelled', { executionId });
         // Process next in queue
@@ -600,15 +605,21 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         const entries = Array.from(this.processPool.entries());
         for (const [executionId, entry] of entries) {
             clearTimeout(entry.timeout);
-            this.killEntryTree(entry.process, 'SIGTERM');
-            // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
-            setTimeout(() => {
-                try {
-                    if (!entry.process.killed)
-                        this.killEntryTree(entry.process, 'SIGKILL');
-                }
-                catch { /* already dead */ }
-            }, 5000).unref();
+            if (entry.abort) {
+                // Settles the promise and owns the SIGTERM -> SIGKILL escalation (#4463).
+                entry.abort();
+            }
+            else {
+                this.killEntryTree(entry.process, 'SIGTERM');
+                // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
+                setTimeout(() => {
+                    try {
+                        if (entry.process.exitCode === null && entry.process.signalCode === null)
+                            this.killEntryTree(entry.process, 'SIGKILL');
+                    }
+                    catch { /* already dead */ }
+                }, 5000).unref();
+            }
             this.emit('cancelled', { executionId });
             cancelled++;
         }
@@ -1075,16 +1086,31 @@ Analyze the above codebase context and provide your response following the forma
                 }
                 catch { /* already dead */ }
             };
+            // #4463 — `child.killed` only means a signal was delivered, not that the
+            // child exited, so escalation keys off the exit state instead.
+            const hasExited = () => child.exitCode !== null || child.signalCode !== null;
+            let escalationHandle;
+            let deadlineHandle;
+            const terminate = () => {
+                if (escalationHandle)
+                    return; // already signalled; never repeat SIGTERM
+                killTree('SIGTERM');
+                // Give it a moment to terminate gracefully, then force it.
+                escalationHandle = setTimeout(() => {
+                    if (!hasExited())
+                        killTree('SIGKILL');
+                }, 5000);
+            };
+            const stopTimers = () => {
+                clearTimeout(escalationHandle);
+                clearTimeout(deadlineHandle);
+            };
+            child.once('exit', () => clearTimeout(escalationHandle));
+            child.once('close', stopTimers);
             // Setup timeout
             const timeoutHandle = setTimeout(() => {
                 if (this.processPool.has(options.executionId)) {
-                    killTree('SIGTERM');
-                    // Give it a moment to terminate gracefully
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            killTree('SIGKILL');
-                        }
-                    }, 5000);
+                    terminate();
                 }
             }, options.timeoutMs);
             // Track in process pool
@@ -1101,8 +1127,17 @@ Analyze the above codebase context and provide your response following the forma
             let resolved = false;
             const cleanup = () => {
                 clearTimeout(timeoutHandle);
+                clearTimeout(deadlineHandle);
                 this.processPool.delete(options.executionId);
             };
+            poolEntry.abort = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                terminate();
+                cleanup();
+                resolve({ success: false, output: stdout || stderr, error: 'Execution cancelled' });
+            };
             child.stdout?.on('data', (data) => {
                 const chunk = data.toString();
                 stdout += chunk;
@@ -1152,13 +1187,15 @@ Analyze the above codebase context and provide your response following the forma
                 });
             });
             // Handle timeout
-            setTimeout(() => {
+            deadlineHandle = setTimeout(() => {
                 if (resolved)
                     return;
                 if (!this.processPool.has(options.executionId))
                     return;
                 resolved = true;
-                killTree('SIGTERM');
+                // Normally a no-op: the timeout handler above already signalled the
+                // tree and owns the SIGKILL escalation (no duplicate SIGTERM).
+                terminate();
                 cleanup();
                 resolve({
                     success: false,

package/dist/src/services/worker-daemon.d.ts

@@ -90,6 +90,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private headlessInitPromise;
     private originalConfig?;
     private fileConfigResourceThresholds?;
+    private fileConfigScalars?;
     private gitIdentity;
     private lastSupervisorRenewalMs;
     constructor(projectRoot: string, config?: Partial<DaemonConfig>);

package/dist/src/services/worker-daemon.js

@@ -143,6 +143,8 @@ export class WorkerDaemon extends EventEmitter {
     // originalConfig — so a config.json override kept losing to whatever
     // .claude-flow/daemon-state.json had persisted from a previous run.
     fileConfigResourceThresholds;
+    // #4462 — the same record for maxConcurrent / workerTimeoutMs.
+    fileConfigScalars;
     // #2661 root-fix — resolved once (git identity doesn't change at runtime)
     // and reused for lease heartbeats + supervisor election, both gated on
     // aiWorkersEnabled since they only matter for the recurring AI schedule.
@@ -161,6 +163,7 @@ export class WorkerDaemon extends EventEmitter {
             maxCpuLoad: fileConfig.maxCpuLoad,
             minFreeMemoryPercent: fileConfig.minFreeMemoryPercent,
         };
+        this.fileConfigScalars = { maxConcurrent: fileConfig.maxConcurrent, workerTimeoutMs: fileConfig.workerTimeoutMs };
         // CPU-proportional smart default instead of hardcoded 2.0
         const cpuCount = WorkerDaemon.getEffectiveCpuCount();
         let smartMaxCpuLoad = Math.max(cpuCount * 0.8, 2.0); // Floor of 2.0 for single-CPU machines
@@ -691,10 +694,16 @@ export class WorkerDaemon extends EventEmitter {
                         this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
                     }
                 }
-                if (typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
+                // #4462 — same rule for the two scalar fields: constructor arg or
+                // config.json beats saved state, which only fills in what neither set.
+                const maxConcurrentExplicit = this.originalConfig?.maxConcurrent !== undefined
+                    || this.fileConfigScalars?.maxConcurrent !== undefined;
+                const workerTimeoutExplicit = this.originalConfig?.workerTimeoutMs !== undefined
+                    || this.fileConfigScalars?.workerTimeoutMs !== undefined;
+                if (!maxConcurrentExplicit && 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) {
+                if (!workerTimeoutExplicit && typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
                     this.config.workerTimeoutMs = saved.config.workerTimeoutMs;
                 }
                 // Restore worker runtime states (runCount, successCount, etc.)

package/package.json

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