kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/daemon.js

@@ -2,6 +2,62 @@
  * V3 CLI Daemon Command
  * Manages background worker daemon (Node.js-based, similar to shell helpers)
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
 import { spawn } from 'child_process';
@@ -9,16 +65,18 @@ import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
 import * as fs from 'fs';
 // Start daemon subcommand
-const startCommand = {
+var startCommand = {
     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: 'quiet', short: 'Q', type: 'boolean', description: 'Suppress output' },
-        { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', default: true },
+        { name: 'background', short: 'b', type: 'boolean', description: 'Run daemon in background (detached process)', "default": true },
         { name: 'foreground', short: 'f', type: 'boolean', description: 'Run daemon in foreground (blocks terminal)' },
         { name: 'headless', type: 'boolean', description: 'Enable headless worker execution (E2B sandbox)' },
         { name: 'sandbox', type: 'string', description: 'Default sandbox mode for headless workers', choices: ['strict', 'permissive', 'disabled'] },
+        { name: 'max-cpu-load', type: 'string', description: 'Override maxCpuLoad resource threshold (e.g. 4.0)' },
+        { name: 'min-free-memory', type: 'string', description: 'Override minFreeMemoryPercent resource threshold (e.g. 15)' },
     ],
     examples: [
         { command: 'claude-flow daemon start', description: 'Start daemon in background (default)' },
@@ -26,189 +84,255 @@ const startCommand = {
         { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
         { command: 'claude-flow daemon start --headless --sandbox strict', description: 'Start with headless workers in strict sandbox' },
     ],
-    action: async (ctx) => {
-        const quiet = ctx.flags.quiet;
-        const foreground = ctx.flags.foreground;
-        const projectRoot = process.cwd();
-        const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
-        // Check if background daemon already running (skip if we ARE the daemon process)
-        if (!isDaemonProcess) {
-            const bgPid = getBackgroundDaemonPid(projectRoot);
-            if (bgPid && isProcessRunning(bgPid)) {
-                if (!quiet) {
-                    output.printWarning(`Daemon already running in background (PID: ${bgPid})`);
-                }
-                return { success: true };
-            }
-        }
-        // Background mode (default): fork a detached process
-        if (!foreground) {
-            return startBackgroundDaemon(projectRoot, quiet);
-        }
-        // Foreground mode: run in current process (blocks terminal)
-        try {
-            const stateDir = join(projectRoot, '.claude-flow');
-            const pidFile = join(stateDir, 'daemon.pid');
-            // Ensure state directory exists
-            if (!fs.existsSync(stateDir)) {
-                fs.mkdirSync(stateDir, { recursive: true });
-            }
-            // Write PID file for foreground mode
-            fs.writeFileSync(pidFile, String(process.pid));
-            // Clean up PID file on exit
-            const cleanup = () => {
-                try {
-                    if (fs.existsSync(pidFile)) {
-                        fs.unlinkSync(pidFile);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var quiet, foreground, projectRoot, isDaemonProcess, config, rawMaxCpu, rawMinMem, NUMERIC_RE, sanitize, thresholds, val, val, bgPid, stateDir, pidFile_1, cleanup_1, spinner, daemon, status, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    quiet = ctx.flags.quiet;
+                    foreground = ctx.flags.foreground;
+                    projectRoot = process.cwd();
+                    isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
+                    config = {};
+                    rawMaxCpu = ctx.flags['max-cpu-load'];
+                    rawMinMem = ctx.flags['min-free-memory'];
+                    NUMERIC_RE = /^\d+(\.\d+)?$/;
+                    sanitize = function (s) { return s.replace(/[\x00-\x1f\x7f-\x9f]/g, ''); };
+                    if (rawMaxCpu || rawMinMem) {
+                        thresholds = {};
+                        if (rawMaxCpu) {
+                            val = parseFloat(rawMaxCpu);
+                            if (NUMERIC_RE.test(rawMaxCpu) && isFinite(val) && val > 0 && val <= 1000) {
+                                thresholds.maxCpuLoad = val;
+                            }
+                            else if (!quiet) {
+                                output.printWarning("Ignoring invalid --max-cpu-load value: " + sanitize(rawMaxCpu));
+                            }
+                        }
+                        if (rawMinMem) {
+                            val = parseFloat(rawMinMem);
+                            if (NUMERIC_RE.test(rawMinMem) && isFinite(val) && val >= 0 && val <= 100) {
+                                thresholds.minFreeMemoryPercent = val;
+                            }
+                            else if (!quiet) {
+                                output.printWarning("Ignoring invalid --min-free-memory value: " + sanitize(rawMinMem));
+                            }
+                        }
+                        if (thresholds.maxCpuLoad !== undefined || thresholds.minFreeMemoryPercent !== undefined) {
+                            config.resourceThresholds = thresholds;
+                        }
                     }
-                }
-                catch { /* ignore */ }
-            };
-            process.on('exit', cleanup);
-            process.on('SIGINT', () => { cleanup(); process.exit(0); });
-            process.on('SIGTERM', () => { cleanup(); process.exit(0); });
-            if (!quiet) {
-                const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
-                spinner.start();
-                const daemon = await startDaemon(projectRoot);
-                const status = daemon.getStatus();
-                spinner.succeed('Worker daemon started (foreground mode)');
-                output.writeln();
-                output.printBox([
-                    `PID: ${status.pid}`,
-                    `Started: ${status.startedAt?.toISOString()}`,
-                    `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
-                    `Max Concurrent: ${status.config.maxConcurrent}`,
-                ].join('\n'), 'Daemon Status');
-                output.writeln();
-                output.writeln(output.bold('Scheduled Workers'));
-                output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Worker', width: 15 },
-                        { key: 'interval', header: 'Interval', width: 12 },
-                        { key: 'priority', header: 'Priority', width: 10 },
-                        { key: 'description', header: 'Description', width: 30 },
-                    ],
-                    data: status.config.workers
-                        .filter(w => w.enabled)
-                        .map(w => ({
-                        type: output.highlight(w.type),
-                        interval: `${Math.round(w.intervalMs / 60000)}min`,
-                        priority: w.priority === 'critical' ? output.error(w.priority) :
-                            w.priority === 'high' ? output.warning(w.priority) :
-                                output.dim(w.priority),
-                        description: w.description,
-                    })),
-                });
-                output.writeln();
-                output.writeln(output.dim('Press Ctrl+C to stop daemon'));
-                // Listen for worker events
-                daemon.on('worker:start', ({ type }) => {
-                    output.writeln(output.dim(`[daemon] Worker starting: ${type}`));
-                });
-                daemon.on('worker:complete', ({ type, durationMs }) => {
-                    output.writeln(output.success(`[daemon] Worker completed: ${type} (${durationMs}ms)`));
-                });
-                daemon.on('worker:error', ({ type, error }) => {
-                    output.writeln(output.error(`[daemon] Worker failed: ${type} - ${error}`));
-                });
-                // Keep process alive
-                await new Promise(() => { }); // Never resolves - daemon runs until killed
-            }
-            else {
-                await startDaemon(projectRoot);
-                await new Promise(() => { }); // Keep alive
+                    // Check if background daemon already running (skip if we ARE the daemon process)
+                    if (!isDaemonProcess) {
+                        bgPid = getBackgroundDaemonPid(projectRoot);
+                        if (bgPid && isProcessRunning(bgPid)) {
+                            if (!quiet) {
+                                output.printWarning("Daemon already running in background (PID: " + bgPid + ")");
+                            }
+                            return [2 /*return*/, { success: true }];
+                        }
+                    }
+                    // Background mode (default): fork a detached process
+                    if (!foreground) {
+                        return [2 /*return*/, startBackgroundDaemon(projectRoot, quiet, rawMaxCpu, rawMinMem)];
+                    }
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 8, , 9]);
+                    stateDir = join(projectRoot, '.claude-flow');
+                    pidFile_1 = join(stateDir, 'daemon.pid');
+                    // Ensure state directory exists
+                    if (!fs.existsSync(stateDir)) {
+                        fs.mkdirSync(stateDir, { recursive: true });
+                    }
+                    // Write PID file for foreground mode
+                    fs.writeFileSync(pidFile_1, String(process.pid));
+                    cleanup_1 = function () {
+                        try {
+                            if (fs.existsSync(pidFile_1)) {
+                                fs.unlinkSync(pidFile_1);
+                            }
+                        }
+                        catch ( /* ignore */_a) { /* ignore */ }
+                    };
+                    process.on('exit', cleanup_1);
+                    process.on('SIGINT', function () { cleanup_1(); process.exit(0); });
+                    process.on('SIGTERM', function () { cleanup_1(); process.exit(0); });
+                    // Ignore SIGHUP on macOS/Linux — prevents daemon death when terminal closes (#1283)
+                    if (process.platform !== 'win32') {
+                        process.on('SIGHUP', function () { });
+                    }
+                    if (!!quiet) return [3 /*break*/, 4];
+                    spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
+                    spinner.start();
+                    return [4 /*yield*/, startDaemon(projectRoot, config)];
+                case 2:
+                    daemon = _b.sent();
+                    status = daemon.getStatus();
+                    spinner.succeed('Worker daemon started (foreground mode)');
+                    output.writeln();
+                    output.printBox([
+                        "PID: " + status.pid,
+                        "Started: " + ((_a = status.startedAt) === null || _a === void 0 ? void 0 : _a.toISOString()),
+                        "Workers: " + status.config.workers.filter(function (w) { return w.enabled; }).length + " enabled",
+                        "Max Concurrent: " + status.config.maxConcurrent,
+                        "Max CPU Load: " + status.config.resourceThresholds.maxCpuLoad,
+                        "Min Free Memory: " + status.config.resourceThresholds.minFreeMemoryPercent + "%",
+                    ].join('\n'), 'Daemon Status');
+                    output.writeln();
+                    output.writeln(output.bold('Scheduled Workers'));
+                    output.printTable({
+                        columns: [
+                            { key: 'type', header: 'Worker', width: 15 },
+                            { key: 'interval', header: 'Interval', width: 12 },
+                            { key: 'priority', header: 'Priority', width: 10 },
+                            { key: 'description', header: 'Description', width: 30 },
+                        ],
+                        data: status.config.workers
+                            .filter(function (w) { return w.enabled; })
+                            .map(function (w) { return ({
+                            type: output.highlight(w.type),
+                            interval: Math.round(w.intervalMs / 60000) + "min",
+                            priority: w.priority === 'critical' ? output.error(w.priority) :
+                                w.priority === 'high' ? output.warning(w.priority) :
+                                    output.dim(w.priority),
+                            description: w.description
+                        }); })
+                    });
+                    output.writeln();
+                    output.writeln(output.dim('Press Ctrl+C to stop daemon'));
+                    // Listen for worker events
+                    daemon.on('worker:start', function (_a) {
+                        var type = _a.type;
+                        output.writeln(output.dim("[daemon] Worker starting: " + type));
+                    });
+                    daemon.on('worker:complete', function (_a) {
+                        var type = _a.type, durationMs = _a.durationMs;
+                        output.writeln(output.success("[daemon] Worker completed: " + type + " (" + durationMs + "ms)"));
+                    });
+                    daemon.on('worker:error', function (_a) {
+                        var type = _a.type, error = _a.error;
+                        output.writeln(output.error("[daemon] Worker failed: " + type + " - " + error));
+                    });
+                    // Keep process alive
+                    return [4 /*yield*/, new Promise(function () { })];
+                case 3:
+                    // Keep process alive
+                    _b.sent(); // Never resolves - daemon runs until killed
+                    return [3 /*break*/, 7];
+                case 4: return [4 /*yield*/, startDaemon(projectRoot, config)];
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, new Promise(function () { })];
+                case 6:
+                    _b.sent(); // Keep alive
+                    _b.label = 7;
+                case 7: return [2 /*return*/, { success: true }];
+                case 8:
+                    error_1 = _b.sent();
+                    output.printError("Failed to start daemon: " + (error_1 instanceof Error ? error_1.message : String(error_1)));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 9: return [2 /*return*/];
             }
-            return { success: true };
-        }
-        catch (error) {
-            output.printError(`Failed to start daemon: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Validate path for security - prevents path traversal and injection
  */
 function validatePath(path, label) {
     // Must be absolute after resolution
-    const resolved = resolve(path);
+    var resolved = resolve(path);
     // Check for null bytes (injection attack)
     if (path.includes('\0')) {
-        throw new Error(`${label} contains null bytes`);
+        throw new Error(label + " contains null bytes");
     }
     // Check for shell metacharacters in path components
     if (/[;&|`$<>]/.test(path)) {
-        throw new Error(`${label} contains shell metacharacters`);
+        throw new Error(label + " contains shell metacharacters");
     }
     // Prevent path traversal outside expected directories
     if (!resolved.includes('.claude-flow') && !resolved.includes('bin')) {
         // Allow only paths within project structure
-        const cwd = process.cwd();
+        var cwd = process.cwd();
         if (!resolved.startsWith(cwd)) {
-            throw new Error(`${label} escapes project directory`);
+            throw new Error(label + " escapes project directory");
         }
     }
 }
 /**
  * Start daemon as a detached background process
  */
-async function startBackgroundDaemon(projectRoot, quiet) {
-    // Validate and resolve project root
-    const resolvedRoot = resolve(projectRoot);
-    validatePath(resolvedRoot, 'Project root');
-    const stateDir = join(resolvedRoot, '.claude-flow');
-    const pidFile = join(stateDir, 'daemon.pid');
-    const logFile = join(stateDir, 'daemon.log');
-    // Validate all paths
-    validatePath(stateDir, 'State directory');
-    validatePath(pidFile, 'PID file');
-    validatePath(logFile, 'Log file');
-    // Ensure state directory exists
-    if (!fs.existsSync(stateDir)) {
-        fs.mkdirSync(stateDir, { recursive: true });
-    }
-    // Get path to CLI (from dist/src/commands/daemon.js -> bin/cli.js)
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    // dist/src/commands -> dist/src -> dist -> package root -> bin/cli.js
-    const cliPath = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
-    validatePath(cliPath, 'CLI path');
-    // Verify CLI path exists
-    if (!fs.existsSync(cliPath)) {
-        output.printError(`CLI not found at: ${cliPath}`);
-        return { success: false, exitCode: 1 };
-    }
-    // Use spawn with explicit arguments instead of shell string interpolation
-    // This prevents command injection via paths
-    const child = spawn(process.execPath, [
-        cliPath,
-        'daemon', 'start', '--foreground', '--quiet'
-    ], {
-        cwd: resolvedRoot,
-        detached: true,
-        stdio: ['ignore', fs.openSync(logFile, 'a'), fs.openSync(logFile, 'a')],
-        env: { ...process.env, CLAUDE_FLOW_DAEMON: '1' },
+function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemory) {
+    return __awaiter(this, void 0, Promise, function () {
+        var resolvedRoot, stateDir, pidFile, logFile, __filename, __dirname, cliPath, isWin, spawnOpts, spawnArgs, SPAWN_NUMERIC_RE, child, pid;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    resolvedRoot = resolve(projectRoot);
+                    validatePath(resolvedRoot, 'Project root');
+                    stateDir = join(resolvedRoot, '.claude-flow');
+                    pidFile = join(stateDir, 'daemon.pid');
+                    logFile = join(stateDir, 'daemon.log');
+                    // Validate all paths
+                    validatePath(stateDir, 'State directory');
+                    validatePath(pidFile, 'PID file');
+                    validatePath(logFile, 'Log file');
+                    // Ensure state directory exists
+                    if (!fs.existsSync(stateDir)) {
+                        fs.mkdirSync(stateDir, { recursive: true });
+                    }
+                    __filename = fileURLToPath(import.meta.url);
+                    __dirname = dirname(__filename);
+                    cliPath = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
+                    validatePath(cliPath, 'CLI path');
+                    // Verify CLI path exists
+                    if (!fs.existsSync(cliPath)) {
+                        output.printError("CLI not found at: " + cliPath);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    isWin = process.platform === 'win32';
+                    spawnOpts = __assign({ cwd: resolvedRoot, detached: !isWin, stdio: ['ignore', fs.openSync(logFile, 'a'), fs.openSync(logFile, 'a')], env: __assign(__assign(__assign({}, process.env), { CLAUDE_FLOW_DAEMON: '1' }), (process.platform === 'darwin' ? { NOHUP: '1' } : {})) }, (isWin ? { shell: true, windowsHide: true } : {}));
+                    spawnArgs = [
+                        cliPath,
+                        'daemon', 'start', '--foreground', '--quiet',
+                    ];
+                    SPAWN_NUMERIC_RE = /^\d+(\.\d+)?$/;
+                    if (maxCpuLoad && SPAWN_NUMERIC_RE.test(maxCpuLoad)) {
+                        spawnArgs.push('--max-cpu-load', maxCpuLoad);
+                    }
+                    if (minFreeMemory && SPAWN_NUMERIC_RE.test(minFreeMemory)) {
+                        spawnArgs.push('--min-free-memory', minFreeMemory);
+                    }
+                    child = spawn(process.execPath, spawnArgs, spawnOpts);
+                    pid = child.pid;
+                    if (!pid || pid <= 0) {
+                        output.printError('Failed to get daemon PID');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    // Unref BEFORE writing PID file — prevents race where parent exits
+                    // but child hasn't fully detached yet (fixes macOS daemon death #1283)
+                    child.unref();
+                    // Small delay to let the child process fully detach on macOS
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                case 1:
+                    // Small delay to let the child process fully detach on macOS
+                    _a.sent();
+                    // Save PID only after child is detached
+                    fs.writeFileSync(pidFile, String(pid));
+                    if (!quiet) {
+                        output.printSuccess("Daemon started in background (PID: " + pid + ")");
+                        output.printInfo("Logs: " + logFile);
+                        output.printInfo("Stop with: claude-flow daemon stop");
+                    }
+                    return [2 /*return*/, { success: true }];
+            }
+        });
     });
-    // Get PID from spawned process directly (no shell echo needed)
-    const pid = child.pid;
-    if (!pid || pid <= 0) {
-        output.printError('Failed to get daemon PID');
-        return { success: false, exitCode: 1 };
-    }
-    // Save PID
-    fs.writeFileSync(pidFile, String(pid));
-    if (!quiet) {
-        output.printSuccess(`Daemon started in background (PID: ${pid})`);
-        output.printInfo(`Logs: ${logFile}`);
-        output.printInfo(`Stop with: claude-flow daemon stop`);
-    }
-    // Unref so parent can exit immediately
-    child.unref();
-    return { success: true };
 }
 // Stop daemon subcommand
-const stopCommand = {
+var stopCommand = {
     name: 'stop',
     description: 'Stop the worker daemon and all background workers',
     options: [
@@ -217,93 +341,121 @@ const stopCommand = {
     examples: [
         { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
     ],
-    action: async (ctx) => {
-        const quiet = ctx.flags.quiet;
-        const projectRoot = process.cwd();
-        try {
-            if (!quiet) {
-                const spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
-                spinner.start();
-                // Try to stop in-process daemon first
-                await stopDaemon();
-                // Also kill any background daemon by PID
-                const killed = await killBackgroundDaemon(projectRoot);
-                spinner.succeed(killed ? 'Worker daemon stopped' : 'Worker daemon was not running');
-            }
-            else {
-                await stopDaemon();
-                await killBackgroundDaemon(projectRoot);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var quiet, projectRoot, spinner, killed, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    quiet = ctx.flags.quiet;
+                    projectRoot = process.cwd();
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 8, , 9]);
+                    if (!!quiet) return [3 /*break*/, 4];
+                    spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
+                    spinner.start();
+                    // Try to stop in-process daemon first
+                    return [4 /*yield*/, stopDaemon()];
+                case 2:
+                    // Try to stop in-process daemon first
+                    _a.sent();
+                    return [4 /*yield*/, killBackgroundDaemon(projectRoot)];
+                case 3:
+                    killed = _a.sent();
+                    spinner.succeed(killed ? 'Worker daemon stopped' : 'Worker daemon was not running');
+                    return [3 /*break*/, 7];
+                case 4: return [4 /*yield*/, stopDaemon()];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, killBackgroundDaemon(projectRoot)];
+                case 6:
+                    _a.sent();
+                    _a.label = 7;
+                case 7: return [2 /*return*/, { success: true }];
+                case 8:
+                    error_2 = _a.sent();
+                    output.printError("Failed to stop daemon: " + (error_2 instanceof Error ? error_2.message : String(error_2)));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 9: return [2 /*return*/];
             }
-            return { success: true };
-        }
-        catch (error) {
-            output.printError(`Failed to stop daemon: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * Kill background daemon process using PID file
  */
-async function killBackgroundDaemon(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
-    if (!fs.existsSync(pidFile)) {
-        return false;
-    }
-    try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-        if (isNaN(pid)) {
-            fs.unlinkSync(pidFile);
-            return false;
-        }
-        // Check if process is running
-        try {
-            process.kill(pid, 0); // Signal 0 = check if alive
-        }
-        catch {
-            // Process not running, clean up stale PID file
-            fs.unlinkSync(pidFile);
-            return false;
-        }
-        // Kill the process
-        process.kill(pid, 'SIGTERM');
-        // Wait a moment then force kill if needed
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        try {
-            process.kill(pid, 0);
-            // Still alive, force kill
-            process.kill(pid, 'SIGKILL');
-        }
-        catch {
-            // Process terminated
-        }
-        // Clean up PID file
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
-        return true;
-    }
-    catch (error) {
-        // Clean up PID file on any error
-        if (fs.existsSync(pidFile)) {
-            fs.unlinkSync(pidFile);
-        }
-        return false;
-    }
+function killBackgroundDaemon(projectRoot) {
+    return __awaiter(this, void 0, Promise, function () {
+        var pidFile, pid, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+                    if (!fs.existsSync(pidFile)) {
+                        return [2 /*return*/, false];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+                    if (isNaN(pid)) {
+                        fs.unlinkSync(pidFile);
+                        return [2 /*return*/, false];
+                    }
+                    // Check if process is running
+                    try {
+                        process.kill(pid, 0); // Signal 0 = check if alive
+                    }
+                    catch (_b) {
+                        // Process not running, clean up stale PID file
+                        fs.unlinkSync(pidFile);
+                        return [2 /*return*/, false];
+                    }
+                    // Kill the process
+                    process.kill(pid, 'SIGTERM');
+                    // Wait a moment then force kill if needed
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                case 2:
+                    // Wait a moment then force kill if needed
+                    _a.sent();
+                    try {
+                        process.kill(pid, 0);
+                        // Still alive, force kill
+                        process.kill(pid, 'SIGKILL');
+                    }
+                    catch (_c) {
+                        // Process terminated
+                    }
+                    // Clean up PID file
+                    if (fs.existsSync(pidFile)) {
+                        fs.unlinkSync(pidFile);
+                    }
+                    return [2 /*return*/, true];
+                case 3:
+                    error_3 = _a.sent();
+                    // Clean up PID file on any error
+                    if (fs.existsSync(pidFile)) {
+                        fs.unlinkSync(pidFile);
+                    }
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
 }
 /**
  * Get PID of background daemon from PID file
  */
 function getBackgroundDaemonPid(projectRoot) {
-    const pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
+    var pidFile = join(projectRoot, '.claude-flow', 'daemon.pid');
     if (!fs.existsSync(pidFile)) {
         return null;
     }
     try {
-        const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
+        var pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
         return isNaN(pid) ? null : pid;
     }
-    catch {
+    catch (_a) {
         return null;
     }
 }
@@ -315,12 +467,12 @@ function isProcessRunning(pid) {
         process.kill(pid, 0); // Signal 0 = check if alive
         return true;
     }
-    catch {
+    catch (_a) {
         return false;
     }
 }
 // Status subcommand
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     description: 'Show daemon and worker status',
     options: [
@@ -332,107 +484,111 @@ const statusCommand = {
         { command: 'claude-flow daemon status -v', description: 'Show detailed status' },
         { command: 'claude-flow daemon status --show-modes', description: 'Show worker execution modes' },
     ],
-    action: async (ctx) => {
-        const verbose = ctx.flags.verbose;
-        const showModes = ctx.flags['show-modes'];
-        const projectRoot = process.cwd();
-        try {
-            const daemon = getDaemon(projectRoot);
-            const status = daemon.getStatus();
-            // Also check for background daemon
-            const bgPid = getBackgroundDaemonPid(projectRoot);
-            const bgRunning = bgPid ? isProcessRunning(bgPid) : false;
-            const isRunning = status.running || bgRunning;
-            const displayPid = bgPid || status.pid;
-            output.writeln();
-            // Daemon status box
-            const statusIcon = isRunning ? output.success('●') : output.error('○');
-            const statusText = isRunning ? output.success('RUNNING') : output.error('STOPPED');
-            const mode = bgRunning ? output.dim(' (background)') : status.running ? output.dim(' (foreground)') : '';
-            output.printBox([
-                `Status: ${statusIcon} ${statusText}${mode}`,
-                `PID: ${displayPid}`,
-                status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
-                `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
-                `Max Concurrent: ${status.config.maxConcurrent}`,
-            ].filter(Boolean).join('\n'), 'Worker Daemon');
-            output.writeln();
-            output.writeln(output.bold('Worker Status'));
-            const workerData = status.config.workers.map(w => {
-                const state = status.workers.get(w.type);
-                // Check for headless mode from worker config or state
-                const isHeadless = w.headless || state?.headless || false;
-                const sandboxMode = w.sandbox || state?.sandbox || null;
-                return {
-                    type: w.enabled ? output.highlight(w.type) : output.dim(w.type),
-                    enabled: w.enabled ? output.success('✓') : output.dim('○'),
-                    status: state?.isRunning ? output.warning('running') :
-                        w.enabled ? output.success('idle') : output.dim('disabled'),
-                    runs: state?.runCount ?? 0,
-                    success: state ? `${Math.round((state.successCount / Math.max(state.runCount, 1)) * 100)}%` : '-',
-                    lastRun: state?.lastRun ? formatTimeAgo(state.lastRun) : output.dim('never'),
-                    nextRun: state?.nextRun && w.enabled ? formatTimeUntil(state.nextRun) : output.dim('-'),
-                    mode: isHeadless ? output.highlight('headless') : output.dim('local'),
-                    sandbox: isHeadless ? (sandboxMode || 'strict') : output.dim('-'),
-                };
-            });
-            // Build columns based on --show-modes flag
-            const baseColumns = [
-                { key: 'type', header: 'Worker', width: 12 },
-                { key: 'enabled', header: 'On', width: 4 },
-                { key: 'status', header: 'Status', width: 10 },
-                { key: 'runs', header: 'Runs', width: 6 },
-                { key: 'success', header: 'Success', width: 8 },
-                { key: 'lastRun', header: 'Last Run', width: 12 },
-                { key: 'nextRun', header: 'Next Run', width: 12 },
-            ];
-            const modeColumns = showModes ? [
-                { key: 'mode', header: 'Mode', width: 10 },
-                { key: 'sandbox', header: 'Sandbox', width: 12 },
-            ] : [];
-            output.printTable({
-                columns: [...baseColumns, ...modeColumns],
-                data: workerData,
-            });
-            if (verbose) {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var verbose, showModes, projectRoot, daemon, status_1, bgPid, bgRunning, isRunning, displayPid, statusIcon, statusText, mode, workerData, baseColumns, modeColumns;
+        return __generator(this, function (_a) {
+            verbose = ctx.flags.verbose;
+            showModes = ctx.flags['show-modes'];
+            projectRoot = process.cwd();
+            try {
+                daemon = getDaemon(projectRoot);
+                status_1 = daemon.getStatus();
+                bgPid = getBackgroundDaemonPid(projectRoot);
+                bgRunning = bgPid ? isProcessRunning(bgPid) : false;
+                isRunning = status_1.running || bgRunning;
+                displayPid = bgPid || status_1.pid;
                 output.writeln();
-                output.writeln(output.bold('Worker Configuration'));
+                statusIcon = isRunning ? output.success('●') : output.error('○');
+                statusText = isRunning ? output.success('RUNNING') : output.error('STOPPED');
+                mode = bgRunning ? output.dim(' (background)') : status_1.running ? output.dim(' (foreground)') : '';
+                output.printBox([
+                    "Status: " + statusIcon + " " + statusText + mode,
+                    "PID: " + displayPid,
+                    status_1.startedAt ? "Started: " + status_1.startedAt.toISOString() : '',
+                    "Workers Enabled: " + status_1.config.workers.filter(function (w) { return w.enabled; }).length,
+                    "Max Concurrent: " + status_1.config.maxConcurrent,
+                    "Max CPU Load: " + status_1.config.resourceThresholds.maxCpuLoad,
+                    "Min Free Memory: " + status_1.config.resourceThresholds.minFreeMemoryPercent + "%",
+                ].filter(Boolean).join('\n'), 'RuFlo Daemon');
+                output.writeln();
+                output.writeln(output.bold('Worker Status'));
+                workerData = status_1.config.workers.map(function (w) {
+                    var _a, _b, _c;
+                    var state = status_1.workers.get(w.type);
+                    // Check for headless mode from worker config or state
+                    var isHeadless = w.headless || ((_a = state) === null || _a === void 0 ? void 0 : _a.headless) || false;
+                    var sandboxMode = w.sandbox || ((_b = state) === null || _b === void 0 ? void 0 : _b.sandbox) || null;
+                    return {
+                        type: w.enabled ? output.highlight(w.type) : output.dim(w.type),
+                        enabled: w.enabled ? output.success('✓') : output.dim('○'),
+                        status: (state === null || state === void 0 ? void 0 : state.isRunning) ? output.warning('running') :
+                            w.enabled ? output.success('idle') : output.dim('disabled'),
+                        runs: (_c = state === null || state === void 0 ? void 0 : state.runCount) !== null && _c !== void 0 ? _c : 0,
+                        success: state ? Math.round((state.successCount / Math.max(state.runCount, 1)) * 100) + "%" : '-',
+                        lastRun: (state === null || state === void 0 ? void 0 : state.lastRun) ? formatTimeAgo(state.lastRun) : output.dim('never'),
+                        nextRun: (state === null || state === void 0 ? void 0 : state.nextRun) && w.enabled ? formatTimeUntil(state.nextRun) : output.dim('-'),
+                        mode: isHeadless ? output.highlight('headless') : output.dim('local'),
+                        sandbox: isHeadless ? (sandboxMode || 'strict') : output.dim('-')
+                    };
+                });
+                baseColumns = [
+                    { key: 'type', header: 'Worker', width: 12 },
+                    { key: 'enabled', header: 'On', width: 4 },
+                    { key: 'status', header: 'Status', width: 10 },
+                    { key: 'runs', header: 'Runs', width: 6 },
+                    { key: 'success', header: 'Success', width: 8 },
+                    { key: 'lastRun', header: 'Last Run', width: 12 },
+                    { key: 'nextRun', header: 'Next Run', width: 12 },
+                ];
+                modeColumns = showModes ? [
+                    { key: 'mode', header: 'Mode', width: 10 },
+                    { key: 'sandbox', header: 'Sandbox', width: 12 },
+                ] : [];
                 output.printTable({
-                    columns: [
-                        { key: 'type', header: 'Worker', width: 12 },
-                        { key: 'interval', header: 'Interval', width: 10 },
-                        { key: 'priority', header: 'Priority', width: 10 },
-                        { key: 'avgDuration', header: 'Avg Duration', width: 12 },
-                        { key: 'description', header: 'Description', width: 30 },
-                    ],
-                    data: status.config.workers.map(w => {
-                        const state = status.workers.get(w.type);
-                        return {
-                            type: w.type,
-                            interval: `${Math.round(w.intervalMs / 60000)}min`,
-                            priority: w.priority,
-                            avgDuration: state?.averageDurationMs ? `${Math.round(state.averageDurationMs)}ms` : '-',
-                            description: w.description,
-                        };
-                    }),
+                    columns: __spreadArray(__spreadArray([], baseColumns, true), modeColumns, true),
+                    data: workerData
                 });
+                if (verbose) {
+                    output.writeln();
+                    output.writeln(output.bold('Worker Configuration'));
+                    output.printTable({
+                        columns: [
+                            { key: 'type', header: 'Worker', width: 12 },
+                            { key: 'interval', header: 'Interval', width: 10 },
+                            { key: 'priority', header: 'Priority', width: 10 },
+                            { key: 'avgDuration', header: 'Avg Duration', width: 12 },
+                            { key: 'description', header: 'Description', width: 30 },
+                        ],
+                        data: status_1.config.workers.map(function (w) {
+                            var state = status_1.workers.get(w.type);
+                            return {
+                                type: w.type,
+                                interval: Math.round(w.intervalMs / 60000) + "min",
+                                priority: w.priority,
+                                avgDuration: (state === null || state === void 0 ? void 0 : state.averageDurationMs) ? Math.round(state.averageDurationMs) + "ms" : '-',
+                                description: w.description
+                            };
+                        })
+                    });
+                }
+                return [2 /*return*/, { success: true, data: status_1 }];
             }
-            return { success: true, data: status };
-        }
-        catch (error) {
-            // Daemon not initialized
-            output.writeln();
-            output.printBox([
-                `Status: ${output.error('○')} ${output.error('NOT INITIALIZED')}`,
-                '',
-                'Run "claude-flow daemon start" to start the daemon',
-            ].join('\n'), 'Worker Daemon');
-            return { success: true };
-        }
-    },
+            catch (error) {
+                // Daemon not initialized
+                output.writeln();
+                output.printBox([
+                    "Status: " + output.error('○') + " " + output.error('NOT INITIALIZED'),
+                    '',
+                    'Run "claude-flow daemon start" to start the daemon',
+                ].join('\n'), 'RuFlo Daemon');
+                return [2 /*return*/, { success: true }];
+            }
+            return [2 /*return*/];
+        });
+    }); }
 };
 // Trigger subcommand - manually run a worker
-const triggerCommand = {
+var triggerCommand = {
     name: 'trigger',
     description: 'Manually trigger a specific worker',
     options: [
@@ -444,40 +600,50 @@ const triggerCommand = {
         { command: 'claude-flow daemon trigger -w audit', description: 'Trigger security audit' },
         { command: 'claude-flow daemon trigger -w audit --headless', description: 'Trigger audit in headless sandbox' },
     ],
-    action: async (ctx) => {
-        const workerType = ctx.flags.worker;
-        if (!workerType) {
-            output.printError('Worker type is required. Use --worker or -w flag.');
-            output.writeln();
-            output.writeln('Available workers: map, audit, optimize, consolidate, testgaps, predict, document, ultralearn, refactor, benchmark, deepdive, preload');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const daemon = getDaemon(process.cwd());
-            const spinner = output.createSpinner({ text: `Running ${workerType} worker...`, spinner: 'dots' });
-            spinner.start();
-            const result = await daemon.triggerWorker(workerType);
-            if (result.success) {
-                spinner.succeed(`Worker ${workerType} completed in ${result.durationMs}ms`);
-                if (result.output) {
-                    output.writeln();
-                    output.writeln(output.bold('Output'));
-                    output.printJson(result.output);
-                }
-            }
-            else {
-                spinner.fail(`Worker ${workerType} failed: ${result.error}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var workerType, daemon, spinner, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    workerType = ctx.flags.worker;
+                    if (!workerType) {
+                        output.printError('Worker type is required. Use --worker or -w flag.');
+                        output.writeln();
+                        output.writeln('Available workers: map, audit, optimize, consolidate, testgaps, predict, document, ultralearn, refactor, benchmark, deepdive, preload');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    daemon = getDaemon(process.cwd());
+                    spinner = output.createSpinner({ text: "Running " + workerType + " worker...", spinner: 'dots' });
+                    spinner.start();
+                    return [4 /*yield*/, daemon.triggerWorker(workerType)];
+                case 2:
+                    result = _a.sent();
+                    if (result.success) {
+                        spinner.succeed("Worker " + workerType + " completed in " + result.durationMs + "ms");
+                        if (result.output) {
+                            output.writeln();
+                            output.writeln(output.bold('Output'));
+                            output.printJson(result.output);
+                        }
+                    }
+                    else {
+                        spinner.fail("Worker " + workerType + " failed: " + result.error);
+                    }
+                    return [2 /*return*/, { success: result.success, data: result }];
+                case 3:
+                    error_4 = _a.sent();
+                    output.printError("Failed to trigger worker: " + (error_4 instanceof Error ? error_4.message : String(error_4)));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: result.success, data: result };
-        }
-        catch (error) {
-            output.printError(`Failed to trigger worker: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Enable/disable worker subcommand
-const enableCommand = {
+var enableCommand = {
     name: 'enable',
     description: 'Enable or disable a specific worker',
     options: [
@@ -488,50 +654,54 @@ const enableCommand = {
         { command: 'claude-flow daemon enable -w predict', description: 'Enable predict worker' },
         { command: 'claude-flow daemon enable -w document --disable', description: 'Disable document worker' },
     ],
-    action: async (ctx) => {
-        const workerType = ctx.flags.worker;
-        const disable = ctx.flags.disable;
-        if (!workerType) {
-            output.printError('Worker type is required. Use --worker or -w flag.');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const daemon = getDaemon(process.cwd());
-            daemon.setWorkerEnabled(workerType, !disable);
-            output.printSuccess(`Worker ${workerType} ${disable ? 'disabled' : 'enabled'}`);
-            return { success: true };
-        }
-        catch (error) {
-            output.printError(`Failed to ${disable ? 'disable' : 'enable'} worker: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var workerType, disable, daemon;
+        return __generator(this, function (_a) {
+            workerType = ctx.flags.worker;
+            disable = ctx.flags.disable;
+            if (!workerType) {
+                output.printError('Worker type is required. Use --worker or -w flag.');
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            }
+            try {
+                daemon = getDaemon(process.cwd());
+                daemon.setWorkerEnabled(workerType, !disable);
+                output.printSuccess("Worker " + workerType + " " + (disable ? 'disabled' : 'enabled'));
+                return [2 /*return*/, { success: true }];
+            }
+            catch (error) {
+                output.printError("Failed to " + (disable ? 'disable' : 'enable') + " worker: " + (error instanceof Error ? error.message : String(error)));
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            }
+            return [2 /*return*/];
+        });
+    }); }
 };
 // Helper functions for time formatting
 function formatTimeAgo(date) {
-    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    var seconds = Math.floor((Date.now() - date.getTime()) / 1000);
     if (seconds < 60)
-        return `${seconds}s ago`;
+        return seconds + "s ago";
     if (seconds < 3600)
-        return `${Math.floor(seconds / 60)}m ago`;
+        return Math.floor(seconds / 60) + "m ago";
     if (seconds < 86400)
-        return `${Math.floor(seconds / 3600)}h ago`;
-    return `${Math.floor(seconds / 86400)}d ago`;
+        return Math.floor(seconds / 3600) + "h ago";
+    return Math.floor(seconds / 86400) + "d ago";
 }
 function formatTimeUntil(date) {
-    const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
+    var seconds = Math.floor((date.getTime() - Date.now()) / 1000);
     if (seconds < 0)
         return 'now';
     if (seconds < 60)
-        return `in ${seconds}s`;
+        return "in " + seconds + "s";
     if (seconds < 3600)
-        return `in ${Math.floor(seconds / 60)}m`;
+        return "in " + Math.floor(seconds / 60) + "m";
     if (seconds < 86400)
-        return `in ${Math.floor(seconds / 3600)}h`;
-    return `in ${Math.floor(seconds / 86400)}d`;
+        return "in " + Math.floor(seconds / 3600) + "h";
+    return "in " + Math.floor(seconds / 86400) + "d";
 }
 // Main daemon command
-export const daemonCommand = {
+export var daemonCommand = {
     name: 'daemon',
     description: 'Manage background worker daemon (Node.js-based, auto-runs like shell helpers)',
     subcommands: [
@@ -549,45 +719,47 @@ export const daemonCommand = {
         { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
         { command: 'claude-flow daemon trigger -w audit', description: 'Run security audit' },
     ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('Worker Daemon - Background Task Management'));
-        output.writeln();
-        output.writeln('Node.js-based background worker system that auto-runs like shell daemons.');
-        output.writeln('Manages 12 specialized workers for continuous optimization and monitoring.');
-        output.writeln();
-        output.writeln(output.bold('Headless Mode'));
-        output.writeln('Workers can run in headless mode using E2B sandboxes for isolated execution.');
-        output.writeln('Use --headless flag with start/trigger commands. Sandbox modes: strict, permissive, disabled.');
-        output.writeln();
-        output.writeln(output.bold('Available Workers'));
-        output.printList([
-            `${output.highlight('map')}         - Codebase mapping (5 min interval)`,
-            `${output.highlight('audit')}       - Security analysis (10 min interval)`,
-            `${output.highlight('optimize')}    - Performance optimization (15 min interval)`,
-            `${output.highlight('consolidate')} - Memory consolidation (30 min interval)`,
-            `${output.highlight('testgaps')}    - Test coverage analysis (20 min interval)`,
-            `${output.highlight('predict')}     - Predictive preloading (2 min, disabled by default)`,
-            `${output.highlight('document')}    - Auto-documentation (60 min, disabled by default)`,
-            `${output.highlight('ultralearn')}  - Deep knowledge acquisition (manual trigger)`,
-            `${output.highlight('refactor')}    - Code refactoring suggestions (manual trigger)`,
-            `${output.highlight('benchmark')}   - Performance benchmarking (manual trigger)`,
-            `${output.highlight('deepdive')}    - Deep code analysis (manual trigger)`,
-            `${output.highlight('preload')}     - Resource preloading (manual trigger)`,
-        ]);
-        output.writeln();
-        output.writeln(output.bold('Subcommands'));
-        output.printList([
-            `${output.highlight('start')}   - Start the daemon`,
-            `${output.highlight('stop')}    - Stop the daemon`,
-            `${output.highlight('status')}  - Show daemon status`,
-            `${output.highlight('trigger')} - Manually run a worker`,
-            `${output.highlight('enable')}  - Enable/disable a worker`,
-        ]);
-        output.writeln();
-        output.writeln('Run "claude-flow daemon <subcommand> --help" for details');
-        return { success: true };
-    },
+    action: function () { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('RuFlo Daemon - Background Task Management'));
+            output.writeln();
+            output.writeln('Node.js-based background worker system that auto-runs like shell daemons.');
+            output.writeln('Manages 12 specialized workers for continuous optimization and monitoring.');
+            output.writeln();
+            output.writeln(output.bold('Headless Mode'));
+            output.writeln('Workers can run in headless mode using E2B sandboxes for isolated execution.');
+            output.writeln('Use --headless flag with start/trigger commands. Sandbox modes: strict, permissive, disabled.');
+            output.writeln();
+            output.writeln(output.bold('Available Workers'));
+            output.printList([
+                output.highlight('map') + "         - Codebase mapping (5 min interval)",
+                output.highlight('audit') + "       - Security analysis (10 min interval)",
+                output.highlight('optimize') + "    - Performance optimization (15 min interval)",
+                output.highlight('consolidate') + " - Memory consolidation (30 min interval)",
+                output.highlight('testgaps') + "    - Test coverage analysis (20 min interval)",
+                output.highlight('predict') + "     - Predictive preloading (2 min, disabled by default)",
+                output.highlight('document') + "    - Auto-documentation (60 min, disabled by default)",
+                output.highlight('ultralearn') + "  - Deep knowledge acquisition (manual trigger)",
+                output.highlight('refactor') + "    - Code refactoring suggestions (manual trigger)",
+                output.highlight('benchmark') + "   - Performance benchmarking (manual trigger)",
+                output.highlight('deepdive') + "    - Deep code analysis (manual trigger)",
+                output.highlight('preload') + "     - Resource preloading (manual trigger)",
+            ]);
+            output.writeln();
+            output.writeln(output.bold('Subcommands'));
+            output.printList([
+                output.highlight('start') + "   - Start the daemon",
+                output.highlight('stop') + "    - Stop the daemon",
+                output.highlight('status') + "  - Show daemon status",
+                output.highlight('trigger') + " - Manually run a worker",
+                output.highlight('enable') + "  - Enable/disable a worker",
+            ]);
+            output.writeln();
+            output.writeln('Run "claude-flow daemon <subcommand> --help" for details');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default daemonCommand;
 //# sourceMappingURL=daemon.js.map