claude-flow 3.10.3 → 3.10.4

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -1,1323 +0,0 @@
-/**
- * Worker Daemon Service
- * Node.js-based background worker system that auto-runs like shell daemons
- *
- * Workers:
- * - map: Codebase mapping (5 min interval)
- * - audit: Security analysis (10 min interval)
- * - optimize: Performance optimization (15 min interval)
- * - consolidate: Memory consolidation (30 min interval)
- * - testgaps: Test coverage analysis (20 min interval)
- */
-import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, renameSync } from 'fs';
-import { cpus } from 'os';
-import { join } from 'path';
-import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
-// Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
-const DEFAULT_WORKERS = [
-    { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
-    { type: 'audit', intervalMs: 10 * 60 * 1000, offsetMs: 2 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: true },
-    { type: 'optimize', intervalMs: 15 * 60 * 1000, offsetMs: 4 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
-    { type: 'consolidate', intervalMs: 30 * 60 * 1000, offsetMs: 6 * 60 * 1000, priority: 'low', description: 'Memory consolidation', enabled: true },
-    { type: 'testgaps', intervalMs: 20 * 60 * 1000, offsetMs: 8 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
-    { type: 'predict', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Predictive preloading', enabled: false },
-    { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
-];
-// 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;
-/**
- * Worker Daemon - Manages background workers with Node.js
- */
-export class WorkerDaemon extends EventEmitter {
-    config;
-    workers = new Map();
-    timers = new Map();
-    // #1845: separate timer for the MCP-dispatch queue poller. Kept off
-    // the per-worker map so stop() clears both kinds without confusion.
-    queuePollTimer;
-    running = false;
-    startedAt;
-    projectRoot;
-    runningWorkers = new Set(); // Track concurrent workers
-    pendingWorkers = []; // Queue for deferred workers
-    // Headless execution support
-    headlessExecutor = null;
-    headlessAvailable = false;
-    // Preserve the original constructor config so we can detect explicit overrides
-    // during state restoration (R1: constructor config takes priority over stale state)
-    originalConfig;
-    constructor(projectRoot, config) {
-        super();
-        this.projectRoot = projectRoot;
-        this.originalConfig = config;
-        const claudeFlowDir = join(projectRoot, '.claude-flow');
-        // Read daemon config from .claude-flow/config.json (Layer B)
-        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
-        // 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.
-        const defaultMinFreeMemory = process.platform === 'darwin' ? 5 : 10;
-        // Priority: constructor arg > config.json > smart default
-        // For resourceThresholds, merge field-by-field so partial overrides
-        // (e.g. only --max-cpu-load) still pick up defaults for other fields.
-        this.config = {
-            autoStart: config?.autoStart ?? fileConfig.autoStart ?? false,
-            logDir: config?.logDir ?? join(claudeFlowDir, 'logs'),
-            stateFile: config?.stateFile ?? join(claudeFlowDir, 'daemon-state.json'),
-            maxConcurrent: config?.maxConcurrent ?? fileConfig.maxConcurrent ?? 2,
-            workerTimeoutMs: config?.workerTimeoutMs ?? fileConfig.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
-            resourceThresholds: {
-                maxCpuLoad: config?.resourceThresholds?.maxCpuLoad ?? fileConfig.maxCpuLoad ?? smartMaxCpuLoad,
-                minFreeMemoryPercent: config?.resourceThresholds?.minFreeMemoryPercent ?? fileConfig.minFreeMemoryPercent ?? defaultMinFreeMemory,
-            },
-            workers: config?.workers ?? DEFAULT_WORKERS,
-        };
-        // Setup graceful shutdown handlers
-        this.setupShutdownHandlers();
-        // #1855: install crash handlers so uncaught exceptions and unhandled
-        // rejections don't leak the PID file or orphan child processes.
-        this.installCrashHandlers();
-        // Ensure directories exist
-        if (!existsSync(claudeFlowDir)) {
-            mkdirSync(claudeFlowDir, { recursive: true });
-        }
-        if (!existsSync(this.config.logDir)) {
-            mkdirSync(this.config.logDir, { recursive: true });
-        }
-        // Initialize worker states
-        this.initializeWorkerStates();
-        // Initialize headless executor (async, non-blocking)
-        this.initHeadlessExecutor().catch((err) => {
-            this.log('warn', `Headless executor init failed: ${err}`);
-        });
-    }
-    /**
-     * Initialize headless executor if Claude Code is available
-     */
-    async initHeadlessExecutor() {
-        try {
-            this.headlessExecutor = new HeadlessWorkerExecutor(this.projectRoot, {
-                maxConcurrent: this.config.maxConcurrent,
-            });
-            this.headlessAvailable = await this.headlessExecutor.isAvailable();
-            if (this.headlessAvailable) {
-                this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events. #1855: also snapshot the
-                // active child PIDs to disk on every transition so the next
-                // lifetime can reap orphans after a hard crash.
-                this.headlessExecutor.on('execution:start', (data) => {
-                    this.writeChildrenSnapshot();
-                    this.emit('headless:start', data);
-                });
-                this.headlessExecutor.on('execution:complete', (data) => {
-                    this.writeChildrenSnapshot();
-                    this.emit('headless:complete', data);
-                });
-                this.headlessExecutor.on('execution:error', (data) => {
-                    this.writeChildrenSnapshot();
-                    this.emit('headless:error', data);
-                });
-                this.headlessExecutor.on('output', (data) => {
-                    this.emit('headless:output', data);
-                });
-            }
-            else {
-                this.log('info', 'Claude Code not found - AI workers will run in local fallback mode');
-            }
-        }
-        catch (error) {
-            this.log('warn', `Failed to initialize headless executor: ${error}`);
-            this.headlessAvailable = false;
-        }
-    }
-    /**
-     * Check if headless execution is available
-     */
-    isHeadlessAvailable() {
-        return this.headlessAvailable;
-    }
-    /**
-     * Get headless executor instance
-     */
-    getHeadlessExecutor() {
-        return this.headlessExecutor;
-    }
-    /**
-     * Detect effective CPU count for the current environment.
-     *
-     * Inside Docker / K8s containers, os.cpus().length reports the HOST cpu
-     * count, not the container limit (Node.js #28762 — wontfix).  We read
-     * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
-     * meaningful under resource-limited containers.
-     */
-    static getEffectiveCpuCount() {
-        // 1. Try cgroup v2: /sys/fs/cgroup/cpu.max
-        try {
-            const cpuMax = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim();
-            const [quotaStr, periodStr] = cpuMax.split(' ');
-            if (quotaStr !== 'max') {
-                const quota = parseInt(quotaStr, 10);
-                const period = parseInt(periodStr, 10);
-                if (quota > 0 && period > 0)
-                    return Math.ceil(quota / period);
-            }
-        }
-        catch { /* not in cgroup v2 */ }
-        // 2. Try cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us
-        try {
-            const quota = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8').trim(), 10);
-            const period = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8').trim(), 10);
-            if (quota > 0 && period > 0)
-                return Math.ceil(quota / period);
-        }
-        catch { /* not in cgroup v1 */ }
-        // 3. Fallback to os.cpus().length
-        return cpus().length || 1;
-    }
-    /**
-     * Read daemon-specific config from .claude-flow/config.{json,yaml,yml}.
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'.
-     * #1844: prefer JSON when both exist (existing behavior) but fall back
-     * to YAML so operators using the v3 canonical YAML format aren't silently
-     * ignored. The chosen path is logged at info level.
-     */
-    readDaemonConfigFromFile(claudeFlowDir) {
-        const jsonPath = join(claudeFlowDir, 'config.json');
-        const yamlPath = join(claudeFlowDir, 'config.yaml');
-        const ymlPath = join(claudeFlowDir, 'config.yml');
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let raw;
-        let chosenPath;
-        if (existsSync(jsonPath)) {
-            try {
-                raw = JSON.parse(readFileSync(jsonPath, 'utf-8'));
-                chosenPath = jsonPath;
-            }
-            catch {
-                return {};
-            }
-        }
-        else if (existsSync(yamlPath) || existsSync(ymlPath)) {
-            const yPath = existsSync(yamlPath) ? yamlPath : ymlPath;
-            try {
-                // Lazy-load yaml so the daemon doesn't hard-require it; if the
-                // dep isn't installed, fall back to the previous warn-only path.
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const yamlMod = require('yaml');
-                const parsed = yamlMod.parse(readFileSync(yPath, 'utf-8'));
-                if (parsed && typeof parsed === 'object') {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    raw = parsed;
-                    chosenPath = yPath;
-                }
-            }
-            catch {
-                this.log('warn', `Found ${yPath} but yaml parser unavailable. Install \`yaml\` or convert to JSON. Falling back to defaults.`);
-                return {};
-            }
-        }
-        if (!raw || !chosenPath) {
-            return {};
-        }
-        this.log('info', `Daemon config loaded from ${chosenPath}`);
-        try {
-            // Support both flat keys at root and nested under scopes.project
-            const cfg = raw?.scopes?.project ?? raw;
-            const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
-            const rawMinMem = cfg['daemon.resourceThresholds.minFreeMemoryPercent'] ?? raw['daemon.resourceThresholds.minFreeMemoryPercent'];
-            const rawMaxConcurrent = cfg['daemon.maxConcurrent'] ?? raw['daemon.maxConcurrent'];
-            const rawTimeout = cfg['daemon.workerTimeoutMs'] ?? raw['daemon.workerTimeoutMs'];
-            return {
-                autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
-                maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
-                workerTimeoutMs: (typeof rawTimeout === 'number' && rawTimeout > 0) ? rawTimeout : undefined,
-                maxCpuLoad: (typeof rawCpuLoad === 'number' && rawCpuLoad > 0 && rawCpuLoad < 1000) ? rawCpuLoad : undefined,
-                minFreeMemoryPercent: (typeof rawMinMem === 'number' && rawMinMem >= 0 && rawMinMem <= 100) ? rawMinMem : undefined,
-            };
-        }
-        catch {
-            return {};
-        }
-    }
-    /**
-     * Setup graceful shutdown handlers
-     */
-    setupShutdownHandlers() {
-        const shutdown = async () => {
-            this.log('info', 'Received shutdown signal, stopping daemon...');
-            await this.stop();
-            process.exit(0);
-        };
-        process.on('SIGTERM', shutdown);
-        process.on('SIGINT', shutdown);
-        process.on('SIGHUP', shutdown);
-    }
-    /**
-     * #1855: install crash handlers for uncaught exceptions and unhandled
-     * rejections. Without these, a thrown error from any timer callback,
-     * worker logic path, or transitive import crashes the daemon process
-     * silently — the PID file leaks and any in-flight child processes
-     * orphan. With these, we log a structured crash record, run stop()
-     * to clean up, then exit 1 so the process actually dies (otherwise
-     * Node would crash anyway after the handler returns).
-     */
-    installCrashHandlers() {
-        const onCrash = (kind, err) => {
-            // Best-effort logging; never throw from inside the crash handler.
-            try {
-                this.writeCrashRecord(kind, err);
-            }
-            catch { /* nothing more we can do */ }
-            try {
-                // Synchronous stop — don't await; the process is dying. Just
-                // remove the PID file and snapshot state so the next start
-                // sees a clean slate.
-                this.removePidFile();
-                this.saveState();
-                // Snapshot any in-flight child PIDs one last time so the next
-                // lifetime can reap them.
-                this.writeChildrenSnapshot();
-            }
-            catch { /* ignore */ }
-            // Exit non-zero so supervisors / shells see the failure.
-            process.exit(1);
-        };
-        process.on('uncaughtException', (err) => onCrash('uncaughtException', err));
-        process.on('unhandledRejection', (err) => onCrash('unhandledRejection', err));
-    }
-    /**
-     * Append a structured crash record to .claude-flow/logs/crash.log.
-     * Inspectable by hand or via `ruflo daemon status` follow-ups.
-     */
-    writeCrashRecord(kind, err) {
-        const logDir = this.config.logDir;
-        if (!existsSync(logDir))
-            mkdirSync(logDir, { recursive: true });
-        const crashLog = join(logDir, 'crash.log');
-        const ts = new Date().toISOString();
-        const message = err instanceof Error ? err.message : String(err);
-        const stack = err instanceof Error && err.stack ? err.stack : '<no stack>';
-        const record = `[${ts}] [${kind}] pid=${process.pid} ${message}\n${stack}\n---\n`;
-        appendFileSync(crashLog, record, 'utf-8');
-        this.log('warn', `Daemon crashed (${kind}): ${message} — see ${crashLog}`);
-    }
-    /**
-     * Path to the on-disk children registry — list of headless worker
-     * child PIDs the daemon currently owns. #1855: written on every
-     * execution:start / :complete / :error transition; read by the next
-     * lifetime to reap orphans after a hard crash.
-     */
-    get childrenFile() {
-        return join(this.projectRoot, '.claude-flow', 'daemon-children.json');
-    }
-    /**
-     * #1856: detect workers that were mid-flight when the previous daemon
-     * lifetime ended. A mid-flight worker has `lastStartedAt > lastRun`
-     * (started after the last successful completion). On crash recovery
-     * we count these as failures so the run-counter math stays consistent
-     * (`runCount === successCount + failureCount`). Workers naturally
-     * retry at their next scheduled interval; we deliberately don't
-     * immediately re-run because the failure may have been deterministic.
-     */
-    detectMidFlightFailures() {
-        let detected = 0;
-        for (const [type, state] of this.workers.entries()) {
-            const startedAt = state.lastStartedAt?.getTime() ?? 0;
-            const lastRunAt = state.lastRun?.getTime() ?? 0;
-            // started after the last successful completion → was mid-flight
-            if (startedAt > 0 && startedAt > lastRunAt) {
-                state.failureCount++;
-                state.isRunning = false;
-                // Don't bump runCount — it was already incremented at start
-                this.log('info', `Worker ${type} was mid-flight at last crash (started ${state.lastStartedAt?.toISOString()}); counted as failure, will retry at next scheduled interval`);
-                detected++;
-            }
-        }
-        if (detected > 0) {
-            this.saveState();
-        }
-    }
-    /**
-     * Snapshot the currently-active headless worker child PIDs to disk.
-     * Best-effort; failures don't propagate.
-     */
-    writeChildrenSnapshot() {
-        if (!this.headlessExecutor)
-            return;
-        try {
-            const pids = this.headlessExecutor.getActiveChildPids();
-            const dir = join(this.projectRoot, '.claude-flow');
-            if (!existsSync(dir))
-                mkdirSync(dir, { recursive: true });
-            writeFileSync(this.childrenFile, JSON.stringify({ pids, daemonPid: process.pid, timestamp: new Date().toISOString() }, null, 2), 'utf-8');
-        }
-        catch { /* best-effort */ }
-    }
-    /**
-     * #1855: reap orphan headless worker children left behind by a
-     * previous crashed lifetime. Reads `.claude-flow/daemon-children.json`,
-     * SIGTERMs any PID still alive that doesn't belong to the current
-     * daemon, then truncates the file. Called at the top of `start()`
-     * so the next lifetime starts with a clean process tree.
-     */
-    reapOrphanedChildren() {
-        const file = this.childrenFile;
-        if (!existsSync(file))
-            return;
-        let snapshot;
-        try {
-            snapshot = JSON.parse(readFileSync(file, 'utf-8'));
-        }
-        catch {
-            try {
-                unlinkSync(file);
-            }
-            catch { /* ignore */ }
-            return;
-        }
-        const pids = Array.isArray(snapshot.pids) ? snapshot.pids : [];
-        let reaped = 0;
-        for (const pid of pids) {
-            if (typeof pid !== 'number' || pid <= 0)
-                continue;
-            if (pid === process.pid)
-                continue; // never our own PID
-            try {
-                process.kill(pid, 0); // is alive?
-                process.kill(pid, 'SIGTERM');
-                reaped++;
-            }
-            catch {
-                // already dead — fine
-            }
-        }
-        if (reaped > 0) {
-            this.log('info', `Reaped ${reaped} orphan headless worker child(ren) from previous lifetime`);
-        }
-        try {
-            unlinkSync(file);
-        }
-        catch { /* ignore */ }
-    }
-    /**
-     * Check if system resources allow worker execution
-     */
-    async canRunWorker() {
-        const os = await import('os');
-        const cpuLoad = os.loadavg()[0];
-        const totalMem = os.totalmem();
-        const freeMem = os.freemem();
-        const freePercent = (freeMem / totalMem) * 100;
-        if (cpuLoad > this.config.resourceThresholds.maxCpuLoad) {
-            return { allowed: false, reason: `CPU load too high: ${cpuLoad.toFixed(2)}` };
-        }
-        if (freePercent < this.config.resourceThresholds.minFreeMemoryPercent) {
-            return { allowed: false, reason: `Memory too low: ${freePercent.toFixed(1)}% free` };
-        }
-        return { allowed: true };
-    }
-    /**
-     * Process pending workers queue
-     *
-     * When executeWorkerWithConcurrencyControl defers a worker (returns null),
-     * we break immediately to avoid a busy-wait loop — the deferred worker is
-     * already back on the pendingWorkers queue by that point. If no workers are
-     * currently running when we break, we schedule a backoff retry so the queue
-     * does not get permanently stuck.
-     */
-    async processPendingWorkers() {
-        while (this.pendingWorkers.length > 0 && this.runningWorkers.size < this.config.maxConcurrent) {
-            const workerType = this.pendingWorkers.shift();
-            const workerConfig = this.config.workers.find(w => w.type === workerType);
-            if (workerConfig) {
-                const result = await this.executeWorkerWithConcurrencyControl(workerConfig);
-                if (result === null) {
-                    // Worker was deferred (resource pressure or concurrency limit).
-                    // Break to avoid tight-looping — the next executeWorker() completion
-                    // will call processPendingWorkers() again via the finally block.
-                    if (this.runningWorkers.size === 0) {
-                        // No workers running means nobody will trigger the finally-block
-                        // callback, so schedule a backoff retry to avoid a stuck queue.
-                        setTimeout(() => this.processPendingWorkers(), 30_000).unref();
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    initializeWorkerStates() {
-        // Try to restore state from file
-        if (existsSync(this.config.stateFile)) {
-            try {
-                const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
-                // CRITICAL: Restore worker config (including enabled flag) from saved state
-                // This fixes #950: daemon enable command not persisting worker state
-                if (saved.config?.workers && Array.isArray(saved.config.workers)) {
-                    for (const savedWorker of saved.config.workers) {
-                        const workerConfig = this.config.workers.find(w => w.type === savedWorker.type);
-                        if (workerConfig && typeof savedWorker.enabled === 'boolean') {
-                            workerConfig.enabled = savedWorker.enabled;
-                        }
-                    }
-                }
-                // Restore resourceThresholds, maxConcurrent, workerTimeoutMs from saved state
-                // Only restore if valid numeric values within sane ranges
-                if (saved.config?.resourceThresholds && !this.originalConfig?.resourceThresholds) {
-                    const rt = saved.config.resourceThresholds;
-                    if (typeof rt.maxCpuLoad === 'number' && rt.maxCpuLoad > 0 && rt.maxCpuLoad < 1000) {
-                        this.config.resourceThresholds.maxCpuLoad = rt.maxCpuLoad;
-                    }
-                    if (typeof rt.minFreeMemoryPercent === 'number' && rt.minFreeMemoryPercent >= 0 && rt.minFreeMemoryPercent <= 100) {
-                        this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
-                    }
-                }
-                if (typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
-                    this.config.maxConcurrent = saved.config.maxConcurrent;
-                }
-                if (typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
-                    this.config.workerTimeoutMs = saved.config.workerTimeoutMs;
-                }
-                // Restore worker runtime states (runCount, successCount, etc.)
-                if (saved.workers) {
-                    for (const [type, state] of Object.entries(saved.workers)) {
-                        const savedState = state;
-                        const lastRunValue = savedState.lastRun;
-                        const lastStartedAtValue = savedState.lastStartedAt;
-                        this.workers.set(type, {
-                            runCount: savedState.runCount || 0,
-                            successCount: savedState.successCount || 0,
-                            failureCount: savedState.failureCount || 0,
-                            averageDurationMs: savedState.averageDurationMs || 0,
-                            lastRun: lastRunValue ? new Date(lastRunValue) : undefined,
-                            lastStartedAt: lastStartedAtValue ? new Date(lastStartedAtValue) : undefined,
-                            nextRun: undefined,
-                            isRunning: false,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignore parse errors, start fresh
-            }
-        }
-        // Initialize any missing workers
-        for (const workerConfig of this.config.workers) {
-            if (!this.workers.has(workerConfig.type)) {
-                this.workers.set(workerConfig.type, {
-                    runCount: 0,
-                    successCount: 0,
-                    failureCount: 0,
-                    averageDurationMs: 0,
-                    isRunning: false,
-                });
-            }
-        }
-    }
-    /**
-     * Get the PID file path for singleton enforcement (#1395 Bug 3).
-     */
-    get pidFile() {
-        return join(this.projectRoot, '.claude-flow', 'daemon.pid');
-    }
-    /**
-     * Check if another daemon instance is already running.
-     * Returns the existing PID if alive, or null if no daemon is running.
-     *
-     * #1853: ignore self-PID matches. The detached-spawn path in
-     * `commands/daemon.ts` writes the child's PID into the file as a
-     * fallback after a 500ms wait. If the child reaches `start()` slower
-     * than the parent's 500ms wait (observed on Node 25 / macOS 26), the
-     * child reads its own PID back from the file and concludes "another
-     * daemon is already running" — so it exits before scheduling workers
-     * and `daemon status` reports STOPPED forever. A daemon process is
-     * never "another instance" of itself; treat self-match as absence.
-     */
-    checkExistingDaemon() {
-        if (!existsSync(this.pidFile))
-            return null;
-        try {
-            const pid = parseInt(readFileSync(this.pidFile, 'utf-8').trim(), 10);
-            if (isNaN(pid))
-                return null;
-            // #1853: a PID file containing our own PID is not "another daemon".
-            // Treat as absent so the start() path proceeds normally.
-            if (pid === process.pid)
-                return null;
-            // Check if process is alive (signal 0 = existence check)
-            process.kill(pid, 0);
-            return pid; // Process is alive
-        }
-        catch {
-            // Process is dead — clean up stale PID file
-            try {
-                unlinkSync(this.pidFile);
-            }
-            catch { /* ignore */ }
-            return null;
-        }
-    }
-    /**
-     * Write PID file for singleton enforcement.
-     */
-    writePidFile() {
-        const dir = join(this.projectRoot, '.claude-flow');
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(this.pidFile, String(process.pid), 'utf-8');
-    }
-    /**
-     * Remove PID file on shutdown.
-     */
-    removePidFile() {
-        try {
-            unlinkSync(this.pidFile);
-        }
-        catch { /* ignore */ }
-    }
-    /**
-     * Start the daemon and all enabled workers
-     */
-    async start() {
-        if (this.running) {
-            this.emit('warning', 'Daemon already running');
-            return;
-        }
-        // PID singleton enforcement (#1395 Bug 3): prevent daemon accumulation
-        const existingPid = this.checkExistingDaemon();
-        if (existingPid !== null) {
-            this.log('info', `Daemon already running (PID: ${existingPid}), skipping start`);
-            this.emit('warning', `Daemon already running (PID: ${existingPid})`);
-            return;
-        }
-        // #1855: reap orphan headless worker children left by a previous
-        // crashed lifetime, BEFORE we mark ourselves running and start
-        // accepting new work. The children file from the prior daemon's
-        // last-snapshot is the authoritative list.
-        this.reapOrphanedChildren();
-        // #1856: detect workers that were mid-flight at the previous crash
-        // and count them as failures so runCount/successCount/failureCount
-        // stay consistent. Workers retry naturally at their next scheduled
-        // interval — we don't immediately re-run them, which avoids a
-        // freshly-recovered daemon hammering the same code path that just
-        // killed it.
-        this.detectMidFlightFailures();
-        this.running = true;
-        this.startedAt = new Date();
-        this.writePidFile();
-        this.emit('started', { pid: process.pid, startedAt: this.startedAt });
-        // Schedule all enabled workers
-        for (const workerConfig of this.config.workers) {
-            if (workerConfig.enabled) {
-                this.scheduleWorker(workerConfig);
-            }
-        }
-        // #1845: poll the MCP-dispatch queue directory so workers requested
-        // via mcp__hooks_worker-dispatch (in a separate process) actually
-        // execute here. Previously the dispatch wrote to a process-local Map
-        // that the daemon could never see.
-        this.queuePollTimer = setInterval(() => {
-            void this.processDispatchQueue();
-        }, 5_000);
-        if (typeof this.queuePollTimer.unref === 'function') {
-            this.queuePollTimer.unref();
-        }
-        // Save state
-        this.saveState();
-        this.log('info', `Daemon started (PID: ${process.pid}, CPUs: ${cpus().length}, workers: ${this.config.workers.filter(w => w.enabled).length}, maxCpuLoad: ${this.config.resourceThresholds.maxCpuLoad}, minFreeMemoryPercent: ${this.config.resourceThresholds.minFreeMemoryPercent}%)`);
-    }
-    /**
-     * #1845: ingest queue entries written by mcp__hooks_worker-dispatch.
-     * Each entry is a JSON file at `.claude-flow/daemon-queue/<id>.json`
-     * with `{ workerId, trigger, context, enqueuedAt }`. We move processed
-     * files to `.claude-flow/daemon-queue/.processed/` so the daemon never
-     * re-runs the same dispatch and operators can inspect history.
-     */
-    async processDispatchQueue() {
-        if (!this.running)
-            return;
-        const queueDir = join(this.projectRoot, '.claude-flow', 'daemon-queue');
-        if (!existsSync(queueDir))
-            return;
-        let entries;
-        try {
-            const fs = await import('fs');
-            entries = fs.readdirSync(queueDir).filter((n) => n.endsWith('.json'));
-        }
-        catch {
-            return;
-        }
-        if (entries.length === 0)
-            return;
-        const fs = await import('fs');
-        const processedDir = join(queueDir, '.processed');
-        if (!existsSync(processedDir)) {
-            try {
-                fs.mkdirSync(processedDir, { recursive: true });
-            }
-            catch { /* race ok */ }
-        }
-        for (const entry of entries) {
-            const src = join(queueDir, entry);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let payload;
-            try {
-                payload = JSON.parse(fs.readFileSync(src, 'utf-8'));
-            }
-            catch {
-                // Malformed entry — quarantine so we don't loop on it
-                try {
-                    fs.renameSync(src, join(processedDir, `bad-${entry}`));
-                }
-                catch { /* nothing more we can do */ }
-                continue;
-            }
-            const trigger = payload?.trigger;
-            const workerId = payload?.workerId;
-            if (!trigger || !this.config.workers.some((w) => w.type === trigger)) {
-                try {
-                    fs.renameSync(src, join(processedDir, `unknown-${entry}`));
-                }
-                catch { /* ok */ }
-                continue;
-            }
-            try {
-                this.log('info', `Dequeued ${trigger}${workerId ? ` (id=${workerId})` : ''} from MCP dispatch queue`);
-                await this.triggerWorker(trigger);
-            }
-            catch (err) {
-                this.log('warn', `Queued worker ${trigger} failed: ${err.message}`);
-            }
-            finally {
-                try {
-                    fs.renameSync(src, join(processedDir, entry));
-                }
-                catch { /* ignore */ }
-            }
-        }
-    }
-    /**
-     * Stop the daemon and all workers
-     */
-    async stop() {
-        if (!this.running) {
-            this.emit('warning', 'Daemon not running');
-            return;
-        }
-        // Clear all timers (convert to array to avoid iterator issues)
-        const timerEntries = Array.from(this.timers.entries());
-        for (const [type, timer] of timerEntries) {
-            clearTimeout(timer);
-            this.log('info', `Stopped worker: ${type}`);
-        }
-        this.timers.clear();
-        // #1845: stop the MCP-dispatch queue poller too.
-        if (this.queuePollTimer) {
-            clearInterval(this.queuePollTimer);
-            this.queuePollTimer = undefined;
-        }
-        this.running = false;
-        this.removePidFile();
-        this.saveState();
-        this.emit('stopped', { stoppedAt: new Date() });
-        this.log('info', 'Daemon stopped');
-    }
-    /**
-     * Get daemon status
-     */
-    getStatus() {
-        return {
-            running: this.running,
-            pid: process.pid,
-            startedAt: this.startedAt,
-            workers: new Map(this.workers),
-            config: this.config,
-        };
-    }
-    /**
-     * Schedule a worker to run at intervals with staggered start
-     */
-    scheduleWorker(workerConfig) {
-        const state = this.workers.get(workerConfig.type);
-        const internalConfig = workerConfig;
-        const staggerOffset = internalConfig.offsetMs || 0;
-        // Calculate initial delay with stagger offset
-        let initialDelay = staggerOffset;
-        if (state.lastRun) {
-            const timeSinceLastRun = Date.now() - state.lastRun.getTime();
-            initialDelay = Math.max(staggerOffset, workerConfig.intervalMs - timeSinceLastRun);
-        }
-        state.nextRun = new Date(Date.now() + initialDelay);
-        const runAndReschedule = async () => {
-            if (!this.running)
-                return;
-            // Use concurrency-controlled execution (P0 fix)
-            await this.executeWorkerWithConcurrencyControl(workerConfig);
-            // Reschedule
-            if (this.running) {
-                const timer = setTimeout(runAndReschedule, workerConfig.intervalMs);
-                this.timers.set(workerConfig.type, timer);
-                state.nextRun = new Date(Date.now() + workerConfig.intervalMs);
-            }
-        };
-        // Schedule first run with stagger offset
-        const timer = setTimeout(runAndReschedule, initialDelay);
-        this.timers.set(workerConfig.type, timer);
-        this.log('info', `Scheduled ${workerConfig.type} (interval: ${workerConfig.intervalMs / 1000}s, first run in ${initialDelay / 1000}s)`);
-    }
-    /**
-     * Execute a worker with concurrency control (P0 fix)
-     */
-    async executeWorkerWithConcurrencyControl(workerConfig) {
-        // Check concurrency limit
-        if (this.runningWorkers.size >= this.config.maxConcurrent) {
-            this.log('info', `Worker ${workerConfig.type} deferred: max concurrent (${this.config.maxConcurrent}) reached`);
-            this.pendingWorkers.push(workerConfig.type);
-            this.emit('worker:deferred', { type: workerConfig.type, reason: 'max_concurrent' });
-            return null;
-        }
-        // Check resource availability
-        const resourceCheck = await this.canRunWorker();
-        if (!resourceCheck.allowed) {
-            this.log('info', `Worker ${workerConfig.type} deferred: ${resourceCheck.reason}`);
-            this.pendingWorkers.push(workerConfig.type);
-            this.emit('worker:deferred', { type: workerConfig.type, reason: resourceCheck.reason });
-            return null;
-        }
-        return this.executeWorker(workerConfig);
-    }
-    /**
-     * Execute a worker with timeout protection
-     */
-    async executeWorker(workerConfig) {
-        const state = this.workers.get(workerConfig.type);
-        const workerId = `${workerConfig.type}_${Date.now()}`;
-        const startTime = Date.now();
-        // Track running worker
-        this.runningWorkers.add(workerConfig.type);
-        state.isRunning = true;
-        state.lastStartedAt = new Date(); // #1856: timestamp the start
-        this.saveState(); // persist before we run anything
-        this.emit('worker:start', { workerId, type: workerConfig.type });
-        this.log('info', `Starting worker: ${workerConfig.type} (${this.runningWorkers.size}/${this.config.maxConcurrent} concurrent)`);
-        try {
-            // Execute worker logic with timeout (P1 fix)
-            // Pass cleanup callback to kill orphan child processes on timeout (#1117)
-            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
-                // On timeout, cancel any headless execution to prevent orphan processes
-                if (this.headlessExecutor) {
-                    this.headlessExecutor.cancelAll();
-                }
-            });
-            const durationMs = Date.now() - startTime;
-            // Update state
-            state.runCount++;
-            state.successCount++;
-            state.lastRun = new Date();
-            state.averageDurationMs = (state.averageDurationMs * (state.runCount - 1) + durationMs) / state.runCount;
-            state.isRunning = false;
-            const result = {
-                workerId,
-                type: workerConfig.type,
-                success: true,
-                durationMs,
-                output,
-                timestamp: new Date(),
-            };
-            this.emit('worker:complete', result);
-            this.log('info', `Worker ${workerConfig.type} completed in ${durationMs}ms`);
-            this.saveState();
-            return result;
-        }
-        catch (error) {
-            const durationMs = Date.now() - startTime;
-            state.runCount++;
-            state.failureCount++;
-            state.lastRun = new Date();
-            state.isRunning = false;
-            const result = {
-                workerId,
-                type: workerConfig.type,
-                success: false,
-                durationMs,
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: new Date(),
-            };
-            this.emit('worker:error', result);
-            this.log('error', `Worker ${workerConfig.type} failed: ${result.error}`);
-            this.saveState();
-            return result;
-        }
-        finally {
-            // Remove from running set and process queue
-            this.runningWorkers.delete(workerConfig.type);
-            this.processPendingWorkers();
-        }
-    }
-    /**
-     * Run a function with timeout (P1 fix)
-     * @param fn - The async function to execute
-     * @param timeoutMs - Timeout in milliseconds
-     * @param timeoutMessage - Error message on timeout
-     * @param onTimeout - Optional cleanup callback invoked when timeout fires (#1117: kills orphan processes)
-     */
-    async runWithTimeout(fn, timeoutMs, timeoutMessage, onTimeout) {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                // Kill orphan child processes before rejecting (#1117)
-                if (onTimeout) {
-                    try {
-                        onTimeout();
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-                reject(new Error(timeoutMessage));
-            }, timeoutMs);
-            fn()
-                .then((result) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                resolve(result);
-            })
-                .catch((error) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * 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) {
-            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);
-                }
-                catch (persistError) {
-                    this.log('warn', `Failed to persist headless result for ${workerConfig.type}: ${persistError.message}`);
-                }
-                return {
-                    mode: 'headless',
-                    ...result,
-                };
-            }
-            catch (error) {
-                this.log('warn', `Headless execution failed for ${workerConfig.type}, falling back to local mode`);
-                this.emit('headless:fallback', {
-                    type: workerConfig.type,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                // Fall through to local execution
-            }
-        }
-        // Local execution (fallback or for non-headless workers)
-        switch (workerConfig.type) {
-            case 'map':
-                return this.runMapWorker();
-            case 'audit':
-                return this.runAuditWorkerLocal();
-            case 'optimize':
-                return this.runOptimizeWorkerLocal();
-            case 'consolidate':
-                return this.runConsolidateWorker();
-            case 'testgaps':
-                return this.runTestGapsWorkerLocal();
-            case 'predict':
-                return this.runPredictWorkerLocal();
-            case 'document':
-                return this.runDocumentWorkerLocal();
-            case 'ultralearn':
-                return this.runUltralearnWorkerLocal();
-            case 'refactor':
-                return this.runRefactorWorkerLocal();
-            case 'deepdive':
-                return this.runDeepdiveWorkerLocal();
-            case 'benchmark':
-                return this.runBenchmarkWorkerLocal();
-            case 'preload':
-                return this.runPreloadWorkerLocal();
-            default:
-                return { status: 'unknown worker type', mode: 'local' };
-        }
-    }
-    /**
-     * #1793: persist a headless worker result to the same metrics file the
-     * local fallback writes to. Without this, AI-mode workers produced rich
-     * structured output (audit findings, perf signals, test-gap analysis)
-     * that lived only in `.claude-flow/logs/headless/*_result.log` and was
-     * invisible to `npx ruflo memory stats` or the metrics consumers.
-     *
-     * The mapping mirrors the `*Local` worker implementations below so a
-     * single consumer path works regardless of execution mode.
-     */
-    persistHeadlessResult(workerType, result) {
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir))
-            mkdirSync(metricsDir, { recursive: true });
-        // Filename mirrors the local-mode worker writes (security-audit.json,
-        // performance.json, test-gaps.json) so a downstream reader doesn't
-        // care which mode produced the data.
-        const filenameMap = {
-            audit: 'security-audit.json',
-            optimize: 'performance.json',
-            testgaps: 'test-gaps.json',
-            document: 'documentation.json',
-            refactor: 'refactor.json',
-            deepdive: 'deepdive.json',
-            ultralearn: 'ultralearn.json',
-            predict: 'predictions.json',
-        };
-        const filename = filenameMap[workerType] ?? `${workerType}.json`;
-        const metricsFile = join(metricsDir, filename);
-        const persisted = {
-            timestamp: result.timestamp instanceof Date ? result.timestamp.toISOString() : new Date().toISOString(),
-            mode: 'headless',
-            workerType,
-            model: result.model,
-            durationMs: result.durationMs,
-            tokensUsed: result.tokensUsed,
-            executionId: result.executionId,
-            success: result.success,
-            // Structured findings live here when the worker emits JSON (e.g. the
-            // audit worker's vulnerability list). Fall back to a raw-output
-            // pointer so consumers can still locate the full log.
-            findings: result.parsedOutput ?? null,
-            rawOutputPreview: typeof result.output === 'string' ? result.output.slice(0, 2000) : undefined,
-            rawOutputLength: typeof result.output === 'string' ? result.output.length : 0,
-        };
-        writeFileSync(metricsFile, JSON.stringify(persisted, null, 2));
-    }
-    // Worker implementations
-    async runMapWorker() {
-        // Scan project structure and update metrics
-        const metricsFile = join(this.projectRoot, '.claude-flow', 'metrics', 'codebase-map.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const map = {
-            timestamp: new Date().toISOString(),
-            projectRoot: this.projectRoot,
-            structure: {
-                hasPackageJson: existsSync(join(this.projectRoot, 'package.json')),
-                hasTsConfig: existsSync(join(this.projectRoot, 'tsconfig.json')),
-                hasClaudeConfig: existsSync(join(this.projectRoot, '.claude')),
-                hasClaudeFlow: existsSync(join(this.projectRoot, '.claude-flow')),
-            },
-            scannedAt: Date.now(),
-        };
-        writeFileSync(metricsFile, JSON.stringify(map, null, 2));
-        return map;
-    }
-    /**
-     * Local audit worker (fallback when headless unavailable)
-     */
-    async runAuditWorkerLocal() {
-        // Basic security checks
-        const auditFile = join(this.projectRoot, '.claude-flow', 'metrics', 'security-audit.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const audit = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            checks: {
-                envFilesProtected: !existsSync(join(this.projectRoot, '.env.local')),
-                gitIgnoreExists: existsSync(join(this.projectRoot, '.gitignore')),
-                noHardcodedSecrets: true, // Would need actual scanning
-            },
-            riskLevel: 'low',
-            recommendations: [],
-            note: 'Install Claude Code CLI for AI-powered security analysis',
-        };
-        writeFileSync(auditFile, JSON.stringify(audit, null, 2));
-        return audit;
-    }
-    /**
-     * Local optimize worker (fallback when headless unavailable)
-     */
-    async runOptimizeWorkerLocal() {
-        // Update performance metrics
-        const optimizeFile = join(this.projectRoot, '.claude-flow', 'metrics', 'performance.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const perf = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            memoryUsage: process.memoryUsage(),
-            uptime: process.uptime(),
-            optimizations: {
-                cacheHitRate: 0.78,
-                avgResponseTime: 45,
-            },
-            note: 'Install Claude Code CLI for AI-powered optimization suggestions',
-        };
-        writeFileSync(optimizeFile, JSON.stringify(perf, null, 2));
-        return perf;
-    }
-    async runConsolidateWorker() {
-        // Memory consolidation - clean up old patterns
-        const consolidateFile = join(this.projectRoot, '.claude-flow', 'metrics', 'consolidation.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const result = {
-            timestamp: new Date().toISOString(),
-            patternsConsolidated: 0,
-            memoryCleaned: 0,
-            duplicatesRemoved: 0,
-        };
-        writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
-        return result;
-    }
-    /**
-     * Local testgaps worker (fallback when headless unavailable)
-     */
-    async runTestGapsWorkerLocal() {
-        // Check for test coverage gaps
-        const testGapsFile = join(this.projectRoot, '.claude-flow', 'metrics', 'test-gaps.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const result = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            hasTestDir: existsSync(join(this.projectRoot, 'tests')) || existsSync(join(this.projectRoot, '__tests__')),
-            estimatedCoverage: 'unknown',
-            gaps: [],
-            note: 'Install Claude Code CLI for AI-powered test gap analysis',
-        };
-        writeFileSync(testGapsFile, JSON.stringify(result, null, 2));
-        return result;
-    }
-    /**
-     * Local predict worker (fallback when headless unavailable)
-     */
-    async runPredictWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            predictions: [],
-            preloaded: [],
-            note: 'Install Claude Code CLI for AI-powered predictions',
-        };
-    }
-    /**
-     * Local document worker (fallback when headless unavailable)
-     */
-    async runDocumentWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            filesDocumented: 0,
-            suggestedDocs: [],
-            note: 'Install Claude Code CLI for AI-powered documentation generation',
-        };
-    }
-    /**
-     * Local ultralearn worker (fallback when headless unavailable)
-     */
-    async runUltralearnWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            patternsLearned: 0,
-            insightsGained: [],
-            note: 'Install Claude Code CLI for AI-powered deep learning',
-        };
-    }
-    /**
-     * Local refactor worker (fallback when headless unavailable)
-     */
-    async runRefactorWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            suggestions: [],
-            duplicatesFound: 0,
-            note: 'Install Claude Code CLI for AI-powered refactoring suggestions',
-        };
-    }
-    /**
-     * Local deepdive worker (fallback when headless unavailable)
-     */
-    async runDeepdiveWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            analysisDepth: 'shallow',
-            findings: [],
-            note: 'Install Claude Code CLI for AI-powered deep code analysis',
-        };
-    }
-    /**
-     * Local benchmark worker
-     */
-    async runBenchmarkWorkerLocal() {
-        const benchmarkFile = join(this.projectRoot, '.claude-flow', 'metrics', 'benchmark.json');
-        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const result = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            benchmarks: {
-                memoryUsage: process.memoryUsage(),
-                cpuUsage: process.cpuUsage(),
-                uptime: process.uptime(),
-            },
-        };
-        writeFileSync(benchmarkFile, JSON.stringify(result, null, 2));
-        return result;
-    }
-    /**
-     * Local preload worker
-     */
-    async runPreloadWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            resourcesPreloaded: 0,
-            cacheStatus: 'active',
-        };
-    }
-    /**
-     * Manually trigger a worker
-     */
-    async triggerWorker(type) {
-        const workerConfig = this.config.workers.find(w => w.type === type);
-        if (!workerConfig) {
-            throw new Error(`Unknown worker type: ${type}`);
-        }
-        return this.executeWorker(workerConfig);
-    }
-    /**
-     * Enable/disable a worker
-     */
-    setWorkerEnabled(type, enabled) {
-        const workerConfig = this.config.workers.find(w => w.type === type);
-        if (workerConfig) {
-            workerConfig.enabled = enabled;
-            if (enabled && this.running) {
-                this.scheduleWorker(workerConfig);
-            }
-            else if (!enabled) {
-                const timer = this.timers.get(type);
-                if (timer) {
-                    clearTimeout(timer);
-                    this.timers.delete(type);
-                }
-            }
-            this.saveState();
-        }
-    }
-    /**
-     * Save daemon state to file
-     */
-    saveState() {
-        const state = {
-            running: this.running,
-            startedAt: this.startedAt?.toISOString(),
-            workers: Object.fromEntries(Array.from(this.workers.entries()).map(([type, state]) => [
-                type,
-                {
-                    ...state,
-                    lastRun: state.lastRun?.toISOString(),
-                    lastStartedAt: state.lastStartedAt?.toISOString(),
-                    nextRun: state.nextRun?.toISOString(),
-                }
-            ])),
-            config: {
-                ...this.config,
-                workers: this.config.workers.map(w => ({ ...w })),
-            },
-            savedAt: new Date().toISOString(),
-        };
-        try {
-            const tmpFile = this.config.stateFile + '.tmp';
-            writeFileSync(tmpFile, JSON.stringify(state, null, 2));
-            renameSync(tmpFile, this.config.stateFile);
-        }
-        catch (error) {
-            this.log('error', `Failed to save state: ${error}`);
-        }
-    }
-    /**
-     * Log message
-     */
-    log(level, message) {
-        const timestamp = new Date().toISOString();
-        const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-        this.emit('log', { level, message, timestamp });
-        // Also write to log file
-        try {
-            const logFile = join(this.config.logDir, 'daemon.log');
-            appendFileSync(logFile, logMessage + '\n');
-        }
-        catch {
-            // Ignore log write errors
-        }
-    }
-}
-// Singleton instance for global access
-let daemonInstance = null;
-/**
- * Get or create daemon instance
- */
-export function getDaemon(projectRoot, config) {
-    if (!daemonInstance && projectRoot) {
-        daemonInstance = new WorkerDaemon(projectRoot, config);
-    }
-    if (!daemonInstance) {
-        throw new Error('Daemon not initialized. Provide projectRoot on first call.');
-    }
-    return daemonInstance;
-}
-/**
- * Start daemon (for use in session-start hook)
- */
-export async function startDaemon(projectRoot, config) {
-    const daemon = getDaemon(projectRoot, config);
-    await daemon.start();
-    return daemon;
-}
-/**
- * Stop daemon
- */
-export async function stopDaemon() {
-    if (daemonInstance) {
-        await daemonInstance.stop();
-    }
-}
-export default WorkerDaemon;
-//# sourceMappingURL=worker-daemon.js.map