@claude-flow/cli 3.26.0 → 3.27.0

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

@@ -22,6 +22,9 @@ import { spawn, execSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { getGlobalAiBudget, isQuotaErrorText } from './global-ai-budget.js';
+import { resolveGitWorkspaceIdentity } from './git-workspace-identity.js';
+import { getAiJobDedupRegistry, computeAiJobKey, hashWorkerConfig } from './ai-job-dedup.js';
 // ============================================
 // Constants
 // ============================================
@@ -517,6 +520,25 @@ export class HeadlessWorkerExecutor extends EventEmitter {
     getActiveCount() {
         return this.processPool.size;
     }
+    /**
+     * #2661 — signal a pool entry's whole process group, not just the head.
+     * Children are spawned `detached: true` on POSIX precisely so their MCP
+     * bridge grandchildren can be reaped with `kill(-pid)`; a head-only kill
+     * orphans them (#2098B).
+     */
+    killEntryTree(proc, signal) {
+        if (process.platform !== 'win32' && typeof proc.pid === 'number') {
+            try {
+                process.kill(-proc.pid, signal);
+                return;
+            }
+            catch { /* fall through */ }
+        }
+        try {
+            proc.kill(signal);
+        }
+        catch { /* already dead */ }
+    }
     /**
      * Cancel a running execution
      */
@@ -526,7 +548,7 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             return false;
         }
         clearTimeout(entry.timeout);
-        entry.process.kill('SIGTERM');
+        this.killEntryTree(entry.process, 'SIGTERM');
         this.processPool.delete(executionId);
         this.emit('cancelled', { executionId });
         // Process next in queue
@@ -542,12 +564,12 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         const entries = Array.from(this.processPool.entries());
         for (const [executionId, entry] of entries) {
             clearTimeout(entry.timeout);
-            entry.process.kill('SIGTERM');
+            this.killEntryTree(entry.process, 'SIGTERM');
             // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
             setTimeout(() => {
                 try {
                     if (!entry.process.killed)
-                        entry.process.kill('SIGKILL');
+                        this.killEntryTree(entry.process, 'SIGKILL');
                 }
                 catch { /* already dead */ }
             }, 5000).unref();
@@ -612,6 +634,63 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         const headless = { ...baseConfig.headless, ...configOverrides };
         const startTime = Date.now();
         const executionId = `${workerType}_${startTime}_${Math.random().toString(36).slice(2, 8)}`;
+        // #2661 invariant 5 — cross-worktree job dedup. Worktrees of one
+        // repository at the same HEAD would otherwise run identical analyses
+        // once per worktree. jobKey = sha256(repositoryId, HEAD, worker,
+        // configHash); a success within the freshness window (the worker's own
+        // interval, floor 10 min) skips the launch entirely — no budget spend,
+        // no process. HEAD moves → new key → the job runs again.
+        const identity = resolveGitWorkspaceIdentity(this.projectRoot);
+        const jobKey = computeAiJobKey({
+            repositoryId: identity.repositoryId,
+            head: identity.head,
+            workerType,
+            configHash: hashWorkerConfig(headless),
+        });
+        const dedup = getAiJobDedupRegistry();
+        const envWindowSecs = Number.parseInt(process.env.RUFLO_AI_DEDUP_WINDOW_SECS || '', 10);
+        const freshnessMs = Number.isFinite(envWindowSecs) && envWindowSecs >= 0
+            ? envWindowSecs * 1000
+            : Math.max(baseConfig.intervalMs || 0, 10 * 60 * 1000);
+        const freshness = dedup.isFresh(jobKey, freshnessMs);
+        if (freshness.fresh) {
+            const skipped = {
+                success: true,
+                dedupSkipped: true,
+                output: '',
+                parsedOutput: undefined,
+                durationMs: 0,
+                model: 'none',
+                sandboxMode: headless.sandbox,
+                workerType,
+                timestamp: new Date(),
+                executionId,
+            };
+            this.logExecution(executionId, 'result', `dedup-skip: job ${jobKey.slice(0, 12)} succeeded ${Math.round((Date.now() - (freshness.lastRunAt ?? Date.now())) / 1000)}s ago (repo ${identity.repositoryId.slice(0, 12)}, head ${identity.head.slice(0, 12) || 'n/a'})`);
+            this.emit('dedup:skipped', { executionId, workerType, jobKey, lastRunAt: freshness.lastRunAt });
+            this.processQueue();
+            return skipped;
+        }
+        // #2661 — every autonomous launch must reserve a slot in the USER-GLOBAL
+        // AI budget before any process is created. This is the hard invariant
+        // that bounds aggregate launches across all worktree daemons: per-daemon
+        // maxConcurrent limits multiply with worktree count, the global budget
+        // does not. Denials return an error result (with a receipted reason)
+        // instead of queueing, so denied work never piles up into a retry storm.
+        const budget = getGlobalAiBudget();
+        const model = headless.model || 'sonnet';
+        const permit = await budget.reserve({ workerType, model, workspace: this.projectRoot });
+        if (!permit.allowed) {
+            const denied = this.createErrorResult(workerType, `Denied by global AI budget: ${permit.reason}`);
+            denied.executionId = executionId;
+            this.logExecution(executionId, 'error', `budget-denied: ${permit.reason}`);
+            // NOTE: deliberately no `emit('error', ...)` here — Node treats
+            // unlistened 'error' events as throws, and callers consume the
+            // returned error result; `budget:denied` is the observable signal.
+            this.emit('budget:denied', { executionId, workerType, reason: permit.reason });
+            this.processQueue();
+            return denied;
+        }
         this.emit('start', { executionId, workerType, config: headless });
         try {
             // Build context from file patterns
@@ -651,6 +730,23 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             };
             // Log result
             this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
+            // #2661 invariant 5 — record the success so sibling worktrees at the
+            // same HEAD skip this job for the rest of the freshness window.
+            if (result.success) {
+                dedup.recordSuccess(jobKey, {
+                    workerType,
+                    repositoryId: identity.repositoryId,
+                    workspace: this.projectRoot,
+                });
+            }
+            // #2661 — a quota/429/usage-limit failure opens the user-global
+            // circuit breaker so EVERY daemon stops launching for the cooldown
+            // window instead of retrying into an exhausted quota. Only inspected
+            // on failure: successful analysis output may legitimately discuss
+            // rate limiting in the user's own code.
+            if (!result.success && isQuotaErrorText(result.error)) {
+                await budget.recordQuotaError(`${workerType}: ${(result.error ?? '').slice(0, 200)}`);
+            }
             this.emit('complete', executionResult);
             return executionResult;
         }
@@ -660,10 +756,15 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             executionResult.executionId = executionId;
             executionResult.durationMs = Date.now() - startTime;
             this.logExecution(executionId, 'error', errorMessage);
+            if (isQuotaErrorText(errorMessage)) {
+                await budget.recordQuotaError(`${workerType}: ${errorMessage.slice(0, 200)}`);
+            }
             this.emit('error', executionResult);
             return executionResult;
         }
         finally {
+            // #2661 — free the global concurrency slot (launch counts persist).
+            await budget.release(permit.permitId);
             // Process next in queue
             this.processQueue();
         }

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

@@ -58,6 +58,7 @@ export interface DaemonConfig {
     };
     ttlMs: number;
     idleShutdownMs: number;
+    aiWorkersEnabled: boolean;
     workers: WorkerConfig[];
 }
 /**
@@ -237,6 +238,19 @@ export declare class WorkerDaemon extends EventEmitter {
      * on its own. A no-op when both limits are disabled (0).
      */
     private startLifecycleMonitor;
+    /**
+     * Decide whether the daemon should self-shutdown, and why. Extracted from
+     * the lifecycle timer so it is testable without racing a 60s interval or
+     * calling process.exit().
+     *
+     * #2661 (invariant 6, containment form): a removed worktree makes its
+     * daemon ineligible within one check interval — the daemon detects that
+     * its workspace directory is gone and shuts down instead of continuing to
+     * schedule jobs against a deleted tree. The full lease architecture
+     * (supervisor-dispatched jobs, heartbeats) is follow-up work; this stops
+     * the leak where recreated/removed worktrees leave schedulers behind.
+     */
+    private lifecycleShutdownReason;
     /**
      * Most recent worker start/finish time across all workers (epoch ms), or
      * null if no worker has ever started. Used for idle-shutdown detection.

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

@@ -155,6 +155,12 @@ export class WorkerDaemon extends EventEmitter {
             // env-or-default and honors an explicit 0 (disable).
             ttlMs: config?.ttlMs ?? fileConfig.ttlMs ?? readEnvSecsAsMs('RUFLO_DAEMON_TTL_SECS', DEFAULT_DAEMON_TTL_MS),
             idleShutdownMs: config?.idleShutdownMs ?? fileConfig.idleShutdownMs ?? readEnvSecsAsMs('RUFLO_DAEMON_IDLE_SECS', DEFAULT_DAEMON_IDLE_SHUTDOWN_MS),
+            // #2661 — AI workers are opt-in: flag > config.json > env > OFF.
+            // Deliberately NOT restored from daemon-state.json (initializeWorkerStates
+            // whitelist) so a stale state file can never resurrect consent.
+            aiWorkersEnabled: config?.aiWorkersEnabled
+                ?? fileConfig.aiWorkersEnabled
+                ?? (process.env.RUFLO_DAEMON_AI_WORKERS === '1'),
             workers: config?.workers ?? DEFAULT_WORKERS,
         };
         // Setup graceful shutdown handlers
@@ -183,6 +189,14 @@ export class WorkerDaemon extends EventEmitter {
      * Initialize headless executor if Claude Code is available
      */
     async initHeadlessExecutor() {
+        // #2661 — scheduled AI workers require explicit consent. Without it,
+        // don't even probe `claude --version`: headlessAvailable stays false,
+        // every worker runs its $0 local path, and a default install produces
+        // zero autonomous Claude launches regardless of worktree count.
+        if (!this.config.aiWorkersEnabled) {
+            this.log('info', 'AI workers disabled (default) - all workers run local-only. Enable with `daemon start --headless`, daemon.aiWorkers.enabled=true, or RUFLO_DAEMON_AI_WORKERS=1 (#2661)');
+            return;
+        }
         try {
             this.headlessExecutor = new HeadlessWorkerExecutor(this.projectRoot, {
                 maxConcurrent: this.config.maxConcurrent,
@@ -342,6 +356,8 @@ export class WorkerDaemon extends EventEmitter {
             // and env var; stored internally as ms. An explicit 0 disables.
             const rawTtl = cfg['daemon.ttlSecs'] ?? raw['daemon.ttlSecs'];
             const rawIdle = cfg['daemon.idleSecs'] ?? raw['daemon.idleSecs'];
+            // #2661 — explicit opt-in for scheduled AI workers.
+            const rawAiEnabled = cfg['daemon.aiWorkers.enabled'] ?? raw['daemon.aiWorkers.enabled'];
             return {
                 autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
                 maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
@@ -350,6 +366,7 @@ export class WorkerDaemon extends EventEmitter {
                 minFreeMemoryPercent: (typeof rawMinMem === 'number' && rawMinMem >= 0 && rawMinMem <= 100) ? rawMinMem : undefined,
                 ttlMs: (typeof rawTtl === 'number' && rawTtl >= 0) ? rawTtl * 1000 : undefined,
                 idleShutdownMs: (typeof rawIdle === 'number' && rawIdle >= 0) ? rawIdle * 1000 : undefined,
+                aiWorkersEnabled: typeof rawAiEnabled === 'boolean' ? rawAiEnabled : undefined,
             };
         }
         catch {
@@ -840,6 +857,16 @@ export class WorkerDaemon extends EventEmitter {
             clearInterval(this.lifecycleTimer);
             this.lifecycleTimer = undefined;
         }
+        // #2661 — reap in-flight headless `claude --print` children. They run
+        // detached (own process group on POSIX) and would otherwise outlive the
+        // daemon; `daemon stop --all` relies on SIGTERM → this path to cancel
+        // active Claude process groups.
+        if (this.headlessExecutor) {
+            try {
+                this.headlessExecutor.cancelAll();
+            }
+            catch { /* best-effort */ }
+        }
         this.running = false;
         this.removePidFile();
         this.saveState();
@@ -859,36 +886,58 @@ export class WorkerDaemon extends EventEmitter {
     startLifecycleMonitor() {
         const ttlMs = this.config.ttlMs;
         const idleMs = this.config.idleShutdownMs;
-        if ((!ttlMs || ttlMs <= 0) && (!idleMs || idleMs <= 0)) {
-            return; // both limits disabled — preserve legacy run-until-stopped behavior
-        }
+        // #2661 — unlike ttl/idle (both optional), the workspace-removal check
+        // always runs, so the monitor is no longer skipped when both limits are
+        // disabled. A daemon whose worktree was deleted must not keep running.
         const CHECK_INTERVAL_MS = 60_000;
         this.lifecycleTimer = setInterval(() => {
             if (!this.running)
                 return;
-            const now = Date.now();
-            const startedMs = this.startedAt?.getTime() ?? now;
-            if (ttlMs > 0 && now - startedMs >= ttlMs) {
-                void this.selfShutdown(`max age ${Math.round(ttlMs / 1000)}s reached`);
-                return;
-            }
-            if (idleMs > 0) {
-                const lastActivity = this.lastWorkerActivityMs() ?? startedMs;
-                if (now - lastActivity >= idleMs) {
-                    void this.selfShutdown(`idle for ${Math.round(idleMs / 1000)}s (no worker activity)`);
-                }
+            const reason = this.lifecycleShutdownReason(Date.now());
+            if (reason) {
+                void this.selfShutdown(reason);
             }
         }, CHECK_INTERVAL_MS);
         if (typeof this.lifecycleTimer.unref === 'function') {
             this.lifecycleTimer.unref();
         }
-        const parts = [];
+        const parts = ['workspace-removal'];
         if (ttlMs > 0)
             parts.push(`ttl=${Math.round(ttlMs / 1000)}s`);
         if (idleMs > 0)
             parts.push(`idle=${Math.round(idleMs / 1000)}s`);
         this.log('info', `Lifecycle monitor active (${parts.join(', ')})`);
     }
+    /**
+     * Decide whether the daemon should self-shutdown, and why. Extracted from
+     * the lifecycle timer so it is testable without racing a 60s interval or
+     * calling process.exit().
+     *
+     * #2661 (invariant 6, containment form): a removed worktree makes its
+     * daemon ineligible within one check interval — the daemon detects that
+     * its workspace directory is gone and shuts down instead of continuing to
+     * schedule jobs against a deleted tree. The full lease architecture
+     * (supervisor-dispatched jobs, heartbeats) is follow-up work; this stops
+     * the leak where recreated/removed worktrees leave schedulers behind.
+     */
+    lifecycleShutdownReason(now) {
+        if (!existsSync(this.projectRoot)) {
+            return 'workspace directory removed (#2661)';
+        }
+        const ttlMs = this.config.ttlMs;
+        const idleMs = this.config.idleShutdownMs;
+        const startedMs = this.startedAt?.getTime() ?? now;
+        if (ttlMs > 0 && now - startedMs >= ttlMs) {
+            return `max age ${Math.round(ttlMs / 1000)}s reached`;
+        }
+        if (idleMs > 0) {
+            const lastActivity = this.lastWorkerActivityMs() ?? startedMs;
+            if (now - lastActivity >= idleMs) {
+                return `idle for ${Math.round(idleMs / 1000)}s (no worker activity)`;
+            }
+        }
+        return null;
+    }
     /**
      * Most recent worker start/finish time across all workers (epoch ms), or
      * null if no worker has ever started. Used for idle-shutdown detection.
@@ -1100,8 +1149,11 @@ export class WorkerDaemon extends EventEmitter {
      * Run the actual worker logic
      */
     async runWorkerLogic(workerConfig) {
-        // Check if this is a headless worker type and headless execution is available
-        if (isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor) {
+        // Check if this is a headless worker type and headless execution is available.
+        // #2661 — aiWorkersEnabled is re-checked here (not just at init) as
+        // defence in depth: no code path may promote a worker to `claude --print`
+        // without explicit consent.
+        if (this.config.aiWorkersEnabled && isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor) {
             try {
                 this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
                 const result = await this.headlessExecutor.execute(workerConfig.type);
@@ -1124,6 +1176,18 @@ export class WorkerDaemon extends EventEmitter {
                     });
                     // Fall through to local switch.
                 }
+                else if (result.dedupSkipped) {
+                    // #2661 invariant 5 — the same job (repositoryId + HEAD + worker +
+                    // config) already succeeded within the freshness window, e.g. in a
+                    // sibling worktree. No model call happened; do NOT overwrite the
+                    // persisted metrics (which hold the real prior result) and do NOT
+                    // fall back to local — the work is already done.
+                    this.log('info', `Worker ${workerConfig.type} dedup-skipped (same repo+HEAD job ran recently in another worktree)`);
+                    return {
+                        mode: 'headless-dedup-skip',
+                        ...result,
+                    };
+                }
                 else {
                     // #1793: persist the headless result to the same metrics files the
                     // local workers write to. Without this, AI-mode runs produced rich

package/package.json

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