Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(daemon): honor explicit scheduled worker selection

Rudy Mizrahi Celekli1fff83fe20ef
diff --git a/v3/@claude-flow/cli/__tests__/daemon-worker-selection-3547.test.ts b/v3/@claude-flow/cli/__tests__/daemon-worker-selection-3547.test.ts
new file mode 100644
index 0000000000..4c1627084c
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/daemon-worker-selection-3547.test.ts
@@ -0,0 +1,72 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { WorkerDaemon } from '../src/services/worker-daemon.js';
+import * as daemonService from '../src/services/worker-daemon.js';
+import { daemonCommand } from '../src/commands/daemon.js';
+import type { CommandContext } from '../src/types.js';
+
+const dirs: string[] = [];
+const signals = ['SIGTERM', 'SIGINT', 'SIGHUP', 'uncaughtException', 'unhandledRejection', 'exit'] as const;
+const listeners = new Map(signals.map(signal => [signal, process.listeners(signal)]));
+afterEach(() => {
+ vi.restoreAllMocks(); vi.unstubAllEnvs();
+ for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+ for (const signal of signals) {
+ for (const listener of process.listeners(signal)) {
+ if (!listeners.get(signal)!.includes(listener)) process.removeListener(signal, listener);
+ }
+ }
+});
+function project(savedWorkers?: Array<{ type: string; enabled: boolean }>) {
+ const dir = mkdtempSync(join(tmpdir(), 'ruflo-worker-selection-')); dirs.push(dir);
+ mkdirSync(join(dir, '.claude-flow'), { recursive: true });
+ if (savedWorkers) writeFileSync(join(dir, '.claude-flow', 'daemon-state.json'), JSON.stringify({ config: { workers: savedWorkers }, workers: {} }));
+ return dir;
+}
+const enabled = (daemon: WorkerDaemon) => daemon.getStatus().config.workers.filter(w => w.enabled).map(w => w.type);
+
+describe('daemon explicit worker selection (#3547)', () => {
+ it.each([['map,audit', ['map', 'audit']], ['predict,document,predict', ['predict', 'document']]])('consumes --workers %s in the public foreground start action', async (workers, selection) => {
+ vi.stubEnv('CLAUDE_FLOW_DAEMON', '1');
+ const start = vi.spyOn(daemonService, 'startDaemon').mockRejectedValue(new Error('test stops before daemon scheduling'));
+ const action = daemonCommand.subcommands!.find(command => command.name === 'start')!.action!;
+ await action({ flags: { foreground: true, quiet: true, workspace: project(), workers }, args: [] } as unknown as CommandContext);
+ expect(start).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ enabledWorkers: selection }));
+ });
+
+ it('overrides persisted enabled flags and keeps disabled workers in the configuration', () => {
+ const dir = project([{ type: 'map', enabled: false }, { type: 'audit', enabled: false }, { type: 'optimize', enabled: true }]);
+ const daemon = new WorkerDaemon(dir, { aiWorkersEnabled: false, enabledWorkers: ['map', 'audit'] });
+ expect(enabled(daemon)).toEqual(['map', 'audit']);
+ expect(daemon.getStatus().config.workers.find(w => w.type === 'optimize')!.enabled).toBe(false);
+ expect(daemon.getStatus().config.workers).toHaveLength(9);
+ expect(daemon.getStatus().config.aiWorkersEnabled).toBe(false);
+ });
+
+ it('preserves saved selection when no explicit selection is supplied', () => {
+ const daemon = new WorkerDaemon(project([{ type: 'optimize', enabled: false }]), { aiWorkersEnabled: false });
+ expect(enabled(daemon)).not.toContain('optimize');
+ expect(enabled(daemon)).toContain('map');
+ });
+
+ it('does not leak a selected or restored worker flag into a different project', () => {
+ new WorkerDaemon(project(), { aiWorkersEnabled: false, enabledWorkers: ['audit'] });
+ const fresh = new WorkerDaemon(project(), { aiWorkersEnabled: false });
+ expect(enabled(fresh)).toEqual(['map', 'audit', 'optimize', 'consolidate', 'testgaps', 'backup', 'harness']);
+ });
+
+ it('supports an explicit empty constructor selection without enabling defaults', () => {
+ expect(enabled(new WorkerDaemon(project(), { aiWorkersEnabled: false, enabledWorkers: [] }))).toEqual([]);
+ });
+
+ it.each(['map,unknown', 'map;echo', ''])('rejects invalid --workers %s before starting', async workers => {
+ vi.stubEnv('CLAUDE_FLOW_DAEMON', '1');
+ const start = vi.spyOn(daemonService, 'startDaemon').mockRejectedValue(new Error('should not reach start'));
+ const action = daemonCommand.subcommands!.find(command => command.name === 'start')!.action!;
+ const result = await action({ flags: { foreground: true, quiet: true, workspace: project(), workers }, args: [] } as unknown as CommandContext);
+ expect(result.success).toBe(false);
+ expect(start).not.toHaveBeenCalled();
+ });
+});
diff --git a/v3/@claude-flow/cli/src/commands/daemon.ts b/v3/@claude-flow/cli/src/commands/daemon.ts
index dbbdbc67f3..981e44d994 100644
--- a/v3/@claude-flow/cli/src/commands/daemon.ts
+++ b/v3/@claude-flow/cli/src/commands/daemon.ts
@@ -5,7 +5,7 @@
import type { Command, CommandContext, CommandResult } from '../types.js';
import { output } from '../output.js';
-import { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, type DaemonConfig } from '../services/worker-daemon.js';
+import { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, type DaemonConfig, parseEnabledWorkers } from '../services/worker-daemon.js';
import { resolveDaemonProjectRoot } from '../services/daemon-autostart.js';
import { spawn, execFile, fork } from 'child_process';
import { fileURLToPath } from 'url';
@@ -18,7 +18,7 @@ const startCommand: Command = {
name: 'start',
description: 'Start the worker daemon with all enabled background workers',
options: [
- { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
+ { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: saved selection or map,audit,optimize,consolidate,testgaps,backup,harness)' },
// ADR-174 M3: consolidate now runs a real memory-distillation pass
// (memory_entries -> episodes/reasoning_patterns/causal_edges) instead of
// a no-op stub. This opt-out skips just that pass for the life of this
@@ -74,6 +74,14 @@ const startCommand: Command = {
// Parse resource threshold overrides from CLI flags
const config: Partial<DaemonConfig> = {};
+ if (ctx.flags.workers !== undefined) {
+ try {
+ config.enabledWorkers = parseEnabledWorkers(ctx.flags.workers as string);
+ } catch (error) {
+ if (!quiet) output.printError((error as Error).message);
+ return { success: false, exitCode: 1 };
+ }
+ }
// #2661: thread --headless into DaemonConfig so it actually gates the
// headless executor. Previously the flag was forwarded to the forked
diff --git a/v3/@claude-flow/cli/src/services/worker-daemon.ts b/v3/@claude-flow/cli/src/services/worker-daemon.ts
index d781dfe2bc..f49a22ca46 100644
--- a/v3/@claude-flow/cli/src/services/worker-daemon.ts
+++ b/v3/@claude-flow/cli/src/services/worker-daemon.ts
@@ -134,6 +134,8 @@ export interface DaemonConfig {
// .claude-flow/config.json, or RUFLO_DAEMON_AI_WORKERS=1.
aiWorkersEnabled: boolean;
workers: WorkerConfig[];
+ /** Explicit selection overrides restored enabled flags; omitted preserves saved state. */
+ enabledWorkers?: readonly WorkerType[];
}
// Worker configuration with staggered offsets to prevent overlap
@@ -154,6 +156,15 @@ const DEFAULT_WORKERS: WorkerConfigInternal[] = [
{ type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
];
+/** Parse only worker types the daemon can actually schedule. */
+export function parseEnabledWorkers(value: string): WorkerType[] {
+ const names = value.split(',');
+ if (!names.length || names.some(name => !DEFAULT_WORKERS.some(worker => worker.type === name))) {
+ throw new Error(`--workers must be a comma-separated list of: ${DEFAULT_WORKERS.map(worker => worker.type).join(',')}`);
+ }
+ return [...new Set(names)] as WorkerType[];
+}
+
// Worker timeout — must exceed the longest per-worker headless timeout (15 min for audit/refactor).
// Previously 5 min, which caused orphan processes when daemon timeout fired before executor timeout (#1117).
const DEFAULT_WORKER_TIMEOUT_MS = 16 * 60 * 1000;
@@ -317,7 +328,7 @@ export class WorkerDaemon extends EventEmitter {
aiWorkersEnabled: config?.aiWorkersEnabled
?? fileConfig.aiWorkersEnabled
?? (process.env.RUFLO_DAEMON_AI_WORKERS === '1'),
- workers: config?.workers ?? DEFAULT_WORKERS,
+ workers: (config?.workers ?? DEFAULT_WORKERS).map(worker => ({ ...worker })),
};
// #2935 — deferred from readDaemonConfigFromFile(): this.config (and
@@ -348,6 +359,10 @@ export class WorkerDaemon extends EventEmitter {
// Initialize worker states
this.initializeWorkerStates();
+ if (config?.enabledWorkers !== undefined) {
+ const selected = new Set(config.enabledWorkers);
+ for (const worker of this.config.workers) worker.enabled = selected.has(worker.type);
+ }
// Initialize headless executor (async, non-blocking) — capture the
// promise so the trigger path (#2251) can await it before checking