claude-flow 3.7.0-alpha.80 → 3.7.0-alpha.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.80",
+  "version": "3.7.0-alpha.81",
   "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/dist/src/services/headless-worker-executor.d.ts

@@ -208,7 +208,20 @@ export declare class HeadlessWorkerExecutor extends EventEmitter {
     private claudeCodeVersion;
     constructor(projectRoot: string, options?: HeadlessExecutorConfig);
     /**
-     * Check if Claude Code CLI is available
+     * Check if Claude Code CLI is available.
+     *
+     * #2110 fix — three issues addressed:
+     *   1. Cache only `true`, never `false`. A transient failure (WSL2 cold
+     *      start, AV scanner, slow shell init) used to set
+     *      `claudeCodeAvailable = false` for the rest of the daemon
+     *      lifetime, so the daemon kept running local stubs even after the
+     *      user fixed `claude auth login`. Now: false results re-probe on
+     *      the next call.
+     *   2. Log the actual error from the catch block instead of silently
+     *      swallowing it. Operators couldn't distinguish timeout / ENOENT /
+     *      auth-failure / exit-code without this.
+     *   3. Honour `CLAUDE_CODE_AVAILABILITY_TIMEOUT_MS` for WSL2 / slow
+     *      systems where `claude --version` can take >5s on first invoke.
      */
     isAvailable(): Promise<boolean>;
     /**

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

@@ -387,17 +387,33 @@ export class HeadlessWorkerExecutor extends EventEmitter {
     // Public API
     // ============================================
     /**
-     * Check if Claude Code CLI is available
+     * Check if Claude Code CLI is available.
+     *
+     * #2110 fix — three issues addressed:
+     *   1. Cache only `true`, never `false`. A transient failure (WSL2 cold
+     *      start, AV scanner, slow shell init) used to set
+     *      `claudeCodeAvailable = false` for the rest of the daemon
+     *      lifetime, so the daemon kept running local stubs even after the
+     *      user fixed `claude auth login`. Now: false results re-probe on
+     *      the next call.
+     *   2. Log the actual error from the catch block instead of silently
+     *      swallowing it. Operators couldn't distinguish timeout / ENOENT /
+     *      auth-failure / exit-code without this.
+     *   3. Honour `CLAUDE_CODE_AVAILABILITY_TIMEOUT_MS` for WSL2 / slow
+     *      systems where `claude --version` can take >5s on first invoke.
      */
     async isAvailable() {
-        if (this.claudeCodeAvailable !== null) {
-            return this.claudeCodeAvailable;
+        // Only the `true` result is cached — `false` is re-probed every call
+        // so a transient failure doesn't poison the rest of the daemon's life.
+        if (this.claudeCodeAvailable === true) {
+            return true;
         }
+        const timeoutMs = Number.parseInt(process.env.CLAUDE_CODE_AVAILABILITY_TIMEOUT_MS || '', 10) || 5000;
         try {
             const output = execSync('claude --version', {
                 encoding: 'utf-8',
                 stdio: 'pipe',
-                timeout: 5000,
+                timeout: timeoutMs,
                 windowsHide: true, // Prevent phantom console windows on Windows
             });
             this.claudeCodeAvailable = true;
@@ -405,9 +421,14 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             this.emit('status', { available: true, version: this.claudeCodeVersion });
             return true;
         }
-        catch {
-            this.claudeCodeAvailable = false;
-            this.emit('status', { available: false });
+        catch (err) {
+            // Don't cache false — let the next call retry. Surface the actual
+            // error via emit so operators can diagnose timeout / ENOENT / auth.
+            this.claudeCodeAvailable = null;
+            const reason = err instanceof Error
+                ? `${err.name}: ${err.message}`.slice(0, 200)
+                : String(err).slice(0, 200);
+            this.emit('status', { available: false, reason });
             return false;
         }
     }

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

@@ -94,6 +94,18 @@ export declare class WorkerDaemon extends EventEmitter {
      * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
      * meaningful under resource-limited containers.
      */
+    /**
+     * #2110 — detect WSL2 / WSL1 so the CPU-load gate can use a sane
+     * default. `/proc/loadavg` on WSL maps in Windows-side process counts
+     * and routinely reports values 100-1000x larger than real Linux load.
+     *
+     * Detection order:
+     *   1. `WSL_DISTRO_NAME` env var (set by Microsoft's WSL launcher)
+     *   2. `WSL_INTEROP` env var (set by recent WSL2)
+     *   3. `/proc/sys/kernel/osrelease` contains "microsoft" or "WSL"
+     *      (kernel build marker; survives env stripping)
+     */
+    static isWslEnvironment(): boolean;
     static getEffectiveCpuCount(): number;
     /**
      * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.

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

@@ -57,7 +57,18 @@ export class WorkerDaemon extends EventEmitter {
         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
+        let smartMaxCpuLoad = Math.max(cpuCount * 0.8, 2.0); // Floor of 2.0 for single-CPU machines
+        // #2110 — WSL2 reports `/proc/loadavg` values that include Windows-side
+        // process counts mapped into the Linux kernel. Real load on a 4-CPU
+        // WSL2 host can be 200-400 even when the Linux side is idle. The
+        // default gate of `cpuCount * 0.8` always trips, deferring every
+        // worker as "CPU load too high" while the daemon reports healthy.
+        // Bump the floor to 1000 when WSL is detected so the gate is
+        // effectively disabled (real load on Linux side rarely exceeds 100
+        // even under heavy contention).
+        if (WorkerDaemon.isWslEnvironment()) {
+            smartMaxCpuLoad = Math.max(smartMaxCpuLoad, 1000);
+        }
         // 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.
@@ -155,6 +166,28 @@ export class WorkerDaemon extends EventEmitter {
      * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
      * meaningful under resource-limited containers.
      */
+    /**
+     * #2110 — detect WSL2 / WSL1 so the CPU-load gate can use a sane
+     * default. `/proc/loadavg` on WSL maps in Windows-side process counts
+     * and routinely reports values 100-1000x larger than real Linux load.
+     *
+     * Detection order:
+     *   1. `WSL_DISTRO_NAME` env var (set by Microsoft's WSL launcher)
+     *   2. `WSL_INTEROP` env var (set by recent WSL2)
+     *   3. `/proc/sys/kernel/osrelease` contains "microsoft" or "WSL"
+     *      (kernel build marker; survives env stripping)
+     */
+    static isWslEnvironment() {
+        if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
+            return true;
+        try {
+            const osrelease = readFileSync('/proc/sys/kernel/osrelease', 'utf8').toLowerCase();
+            if (osrelease.includes('microsoft') || osrelease.includes('wsl'))
+                return true;
+        }
+        catch { /* not on Linux or /proc inaccessible */ }
+        return false;
+    }
     static getEffectiveCpuCount() {
         // 1. Try cgroup v2: /sys/fs/cgroup/cpu.max
         try {
@@ -909,21 +942,42 @@ export class WorkerDaemon extends EventEmitter {
             try {
                 this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
                 const result = await this.headlessExecutor.execute(workerConfig.type);
-                // #1793: persist the headless result to the same metrics files the
-                // local workers write to. Without this, AI-mode runs produced rich
-                // parsedOutput that lived only in `.claude-flow/logs/headless/*` and
-                // never reached `.claude-flow/metrics/<name>.json` — `memory stats`
-                // and downstream consumers saw nothing despite successful runs.
-                try {
-                    this.persistHeadlessResult(workerConfig.type, result);
+                // #2110 — `HeadlessWorkerExecutor.execute()` returns
+                // `createErrorResult(...)` with `success: false` when
+                // `isAvailable()` is false, instead of throwing. The previous
+                // try/catch never fired in that path, and the result was
+                // persisted as mode:"headless" despite being a stub. Downstream
+                // dashboards / `memory stats` couldn't distinguish a real AI
+                // run from a fallback. Treat falsy success the same as throw.
+                const ok = result?.success === true;
+                if (!ok) {
+                    const reason = result?.error ||
+                        result?.note ||
+                        'headless executor reported success=false';
+                    this.log('warn', `Headless ${workerConfig.type} returned success=false (${String(reason).slice(0, 200)}); falling back to local mode`);
+                    this.emit('headless:fallback', {
+                        type: workerConfig.type,
+                        error: String(reason).slice(0, 500),
+                    });
+                    // Fall through to local switch.
                 }
-                catch (persistError) {
-                    this.log('warn', `Failed to persist headless result for ${workerConfig.type}: ${persistError.message}`);
+                else {
+                    // #1793: persist the headless result to the same metrics files the
+                    // local workers write to. Without this, AI-mode runs produced rich
+                    // parsedOutput that lived only in `.claude-flow/logs/headless/*` and
+                    // never reached `.claude-flow/metrics/<name>.json` — `memory stats`
+                    // and downstream consumers saw nothing despite successful runs.
+                    try {
+                        this.persistHeadlessResult(workerConfig.type, result);
+                    }
+                    catch (persistError) {
+                        this.log('warn', `Failed to persist headless result for ${workerConfig.type}: ${persistError.message}`);
+                    }
+                    return {
+                        mode: 'headless',
+                        ...result,
+                    };
                 }
-                return {
-                    mode: 'headless',
-                    ...result,
-                };
             }
             catch (error) {
                 this.log('warn', `Headless execution failed for ${workerConfig.type}, falling back to local mode`);

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.80",
+  "version": "3.7.0-alpha.81",
   "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",