kynjal-cli 3.1.3 → 4.0.0

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

@@ -9,12 +9,75 @@
  * - consolidate: Memory consolidation (30 min interval)
  * - testgaps: Test coverage analysis (20 min interval)
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } 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 = [
+var 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 },
@@ -24,712 +87,1026 @@ const DEFAULT_WORKERS = [
     { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
 ];
 // Worker timeout (5 minutes max per worker)
-const DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;
+var DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;
 /**
  * Worker Daemon - Manages background workers with Node.js
  */
-export class WorkerDaemon extends EventEmitter {
-    config;
-    workers = new Map();
-    timers = new Map();
-    running = false;
-    startedAt;
-    projectRoot;
-    runningWorkers = new Set(); // Track concurrent workers
-    pendingWorkers = []; // Queue for deferred workers
-    // Headless execution support
-    headlessExecutor = null;
-    headlessAvailable = false;
-    constructor(projectRoot, config) {
-        super();
-        this.projectRoot = projectRoot;
-        const claudeFlowDir = join(projectRoot, '.claude-flow');
-        this.config = {
-            autoStart: config?.autoStart ?? false, // P1 fix: Default to false for explicit consent
-            logDir: config?.logDir ?? join(claudeFlowDir, 'logs'),
-            stateFile: config?.stateFile ?? join(claudeFlowDir, 'daemon-state.json'),
-            maxConcurrent: config?.maxConcurrent ?? 2, // P0 fix: Limit concurrent workers
-            workerTimeoutMs: config?.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
-            resourceThresholds: config?.resourceThresholds ?? {
-                maxCpuLoad: 2.0,
-                minFreeMemoryPercent: 20,
+var WorkerDaemon = /** @class */ (function (_super) {
+    __extends(WorkerDaemon, _super);
+    function WorkerDaemon(projectRoot, config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var _this = _super.call(this) || this;
+        _this.workers = new Map();
+        _this.timers = new Map();
+        _this.running = false;
+        _this.runningWorkers = new Set(); // Track concurrent workers
+        _this.pendingWorkers = []; // Queue for deferred workers
+        // Headless execution support
+        _this.headlessExecutor = null;
+        _this.headlessAvailable = false;
+        _this.projectRoot = projectRoot;
+        _this.originalConfig = config;
+        var claudeFlowDir = join(projectRoot, '.claude-flow');
+        // Read daemon config from .claude-flow/config.json (Layer B)
+        var fileConfig = _this.readDaemonConfigFromFile(claudeFlowDir);
+        // CPU-proportional smart default instead of hardcoded 2.0
+        var cpuCount = WorkerDaemon.getEffectiveCpuCount();
+        var 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.
+        var 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: (_b = (_a = config === null || config === void 0 ? void 0 : config.autoStart) !== null && _a !== void 0 ? _a : fileConfig.autoStart) !== null && _b !== void 0 ? _b : false,
+            logDir: (_c = config === null || config === void 0 ? void 0 : config.logDir) !== null && _c !== void 0 ? _c : join(claudeFlowDir, 'logs'),
+            stateFile: (_d = config === null || config === void 0 ? void 0 : config.stateFile) !== null && _d !== void 0 ? _d : join(claudeFlowDir, 'daemon-state.json'),
+            maxConcurrent: (_f = (_e = config === null || config === void 0 ? void 0 : config.maxConcurrent) !== null && _e !== void 0 ? _e : fileConfig.maxConcurrent) !== null && _f !== void 0 ? _f : 2,
+            workerTimeoutMs: (_h = (_g = config === null || config === void 0 ? void 0 : config.workerTimeoutMs) !== null && _g !== void 0 ? _g : fileConfig.workerTimeoutMs) !== null && _h !== void 0 ? _h : DEFAULT_WORKER_TIMEOUT_MS,
+            resourceThresholds: {
+                maxCpuLoad: (_l = (_k = (_j = config === null || config === void 0 ? void 0 : config.resourceThresholds) === null || _j === void 0 ? void 0 : _j.maxCpuLoad) !== null && _k !== void 0 ? _k : fileConfig.maxCpuLoad) !== null && _l !== void 0 ? _l : smartMaxCpuLoad,
+                minFreeMemoryPercent: (_p = (_o = (_m = config === null || config === void 0 ? void 0 : config.resourceThresholds) === null || _m === void 0 ? void 0 : _m.minFreeMemoryPercent) !== null && _o !== void 0 ? _o : fileConfig.minFreeMemoryPercent) !== null && _p !== void 0 ? _p : defaultMinFreeMemory
             },
-            workers: config?.workers ?? DEFAULT_WORKERS,
+            workers: (_q = config === null || config === void 0 ? void 0 : config.workers) !== null && _q !== void 0 ? _q : DEFAULT_WORKERS
         };
         // Setup graceful shutdown handlers
-        this.setupShutdownHandlers();
+        _this.setupShutdownHandlers();
         // Ensure directories exist
         if (!existsSync(claudeFlowDir)) {
             mkdirSync(claudeFlowDir, { recursive: true });
         }
-        if (!existsSync(this.config.logDir)) {
-            mkdirSync(this.config.logDir, { recursive: true });
+        if (!existsSync(_this.config.logDir)) {
+            mkdirSync(_this.config.logDir, { recursive: true });
         }
         // Initialize worker states
-        this.initializeWorkerStates();
+        _this.initializeWorkerStates();
         // Initialize headless executor (async, non-blocking)
-        this.initHeadlessExecutor().catch((err) => {
-            this.log('warn', `Headless executor init failed: ${err}`);
+        _this.initHeadlessExecutor()["catch"](function (err) {
+            _this.log('warn', "Headless executor init failed: " + err);
         });
+        return _this;
     }
     /**
      * Initialize headless executor if Claude Code is available
      */
-    async initHeadlessExecutor() {
-        try {
-            this.headlessExecutor = new HeadlessWorkerExecutor(this.projectRoot, {
-                maxConcurrent: this.config.maxConcurrent,
+    WorkerDaemon.prototype.initHeadlessExecutor = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a, error_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        this.headlessExecutor = new HeadlessWorkerExecutor(this.projectRoot, {
+                            maxConcurrent: this.config.maxConcurrent
+                        });
+                        _a = this;
+                        return [4 /*yield*/, this.headlessExecutor.isAvailable()];
+                    case 1:
+                        _a.headlessAvailable = _b.sent();
+                        if (this.headlessAvailable) {
+                            this.log('info', 'Claude Code headless mode available - AI workers enabled');
+                            // Forward headless executor events
+                            this.headlessExecutor.on('execution:start', function (data) {
+                                _this.emit('headless:start', data);
+                            });
+                            this.headlessExecutor.on('execution:complete', function (data) {
+                                _this.emit('headless:complete', data);
+                            });
+                            this.headlessExecutor.on('execution:error', function (data) {
+                                _this.emit('headless:error', data);
+                            });
+                            this.headlessExecutor.on('output', function (data) {
+                                _this.emit('headless:output', data);
+                            });
+                        }
+                        else {
+                            this.log('info', 'Claude Code not found - AI workers will run in local fallback mode');
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _b.sent();
+                        this.log('warn', "Failed to initialize headless executor: " + error_1);
+                        this.headlessAvailable = false;
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
             });
-            this.headlessAvailable = await this.headlessExecutor.isAvailable();
-            if (this.headlessAvailable) {
-                this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
-                this.headlessExecutor.on('execution:start', (data) => {
-                    this.emit('headless:start', data);
-                });
-                this.headlessExecutor.on('execution:complete', (data) => {
-                    this.emit('headless:complete', data);
-                });
-                this.headlessExecutor.on('execution:error', (data) => {
-                    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() {
+    WorkerDaemon.prototype.isHeadlessAvailable = function () {
         return this.headlessAvailable;
-    }
+    };
     /**
      * Get headless executor instance
      */
-    getHeadlessExecutor() {
+    WorkerDaemon.prototype.getHeadlessExecutor = function () {
         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.
+     */
+    WorkerDaemon.getEffectiveCpuCount = function () {
+        // 1. Try cgroup v2: /sys/fs/cgroup/cpu.max
+        try {
+            var cpuMax = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim();
+            var _a = cpuMax.split(' '), quotaStr = _a[0], periodStr = _a[1];
+            if (quotaStr !== 'max') {
+                var quota = parseInt(quotaStr, 10);
+                var period = parseInt(periodStr, 10);
+                if (quota > 0 && period > 0)
+                    return Math.ceil(quota / period);
+            }
+        }
+        catch ( /* not in cgroup v2 */_b) { /* not in cgroup v2 */ }
+        // 2. Try cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us
+        try {
+            var quota = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8').trim(), 10);
+            var 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 */_c) { /* not in cgroup v1 */ }
+        // 3. Fallback to os.cpus().length
+        return cpus().length || 1;
+    };
+    /**
+     * Read daemon-specific config from .claude-flow/config.json
+     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
+     */
+    WorkerDaemon.prototype.readDaemonConfigFromFile = function (claudeFlowDir) {
+        var _a, _b, _c, _d, _e, _f;
+        var configPath = join(claudeFlowDir, 'config.json');
+        if (!existsSync(configPath))
+            return {};
+        try {
+            var raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            // Support both flat keys at root and nested under scopes.project
+            var cfg = (_b = (_a = raw === null || raw === void 0 ? void 0 : raw.scopes) === null || _a === void 0 ? void 0 : _a.project) !== null && _b !== void 0 ? _b : raw;
+            var rawCpuLoad = (_c = cfg['daemon.resourceThresholds.maxCpuLoad']) !== null && _c !== void 0 ? _c : raw['daemon.resourceThresholds.maxCpuLoad'];
+            var rawMinMem = (_d = cfg['daemon.resourceThresholds.minFreeMemoryPercent']) !== null && _d !== void 0 ? _d : raw['daemon.resourceThresholds.minFreeMemoryPercent'];
+            var rawMaxConcurrent = (_e = cfg['daemon.maxConcurrent']) !== null && _e !== void 0 ? _e : raw['daemon.maxConcurrent'];
+            var rawTimeout = (_f = cfg['daemon.workerTimeoutMs']) !== null && _f !== void 0 ? _f : 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 (_g) {
+            return {};
+        }
+    };
     /**
      * Setup graceful shutdown handlers
      */
-    setupShutdownHandlers() {
-        const shutdown = async () => {
-            this.log('info', 'Received shutdown signal, stopping daemon...');
-            await this.stop();
-            process.exit(0);
-        };
+    WorkerDaemon.prototype.setupShutdownHandlers = function () {
+        var _this = this;
+        var shutdown = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.log('info', 'Received shutdown signal, stopping daemon...');
+                        return [4 /*yield*/, this.stop()];
+                    case 1:
+                        _a.sent();
+                        process.exit(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         process.on('SIGTERM', shutdown);
         process.on('SIGINT', shutdown);
         process.on('SIGHUP', shutdown);
-    }
+    };
     /**
      * 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 };
-    }
+    WorkerDaemon.prototype.canRunWorker = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var os, cpuLoad, totalMem, freeMem, freePercent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, import('os')];
+                    case 1:
+                        os = _a.sent();
+                        cpuLoad = os.loadavg()[0];
+                        totalMem = os.totalmem();
+                        freeMem = os.freemem();
+                        freePercent = (freeMem / totalMem) * 100;
+                        if (cpuLoad > this.config.resourceThresholds.maxCpuLoad) {
+                            return [2 /*return*/, { allowed: false, reason: "CPU load too high: " + cpuLoad.toFixed(2) }];
+                        }
+                        if (freePercent < this.config.resourceThresholds.minFreeMemoryPercent) {
+                            return [2 /*return*/, { allowed: false, reason: "Memory too low: " + freePercent.toFixed(1) + "% free" }];
+                        }
+                        return [2 /*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) {
-                await this.executeWorkerWithConcurrencyControl(workerConfig);
-            }
-        }
-    }
-    initializeWorkerStates() {
+    WorkerDaemon.prototype.processPendingWorkers = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _loop_1, this_1, state_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _loop_1 = function () {
+                            var workerType, workerConfig, result;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        workerType = this_1.pendingWorkers.shift();
+                                        workerConfig = this_1.config.workers.find(function (w) { return w.type === workerType; });
+                                        if (!workerConfig) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this_1.executeWorkerWithConcurrencyControl(workerConfig)];
+                                    case 1:
+                                        result = _b.sent();
+                                        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_1.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(function () { return _this.processPendingWorkers(); }, 30000).unref();
+                                            }
+                                            return [2 /*return*/, "break"];
+                                        }
+                                        _b.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!(this.pendingWorkers.length > 0 && this.runningWorkers.size < this.config.maxConcurrent)) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_1()];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (state_1 === "break")
+                            return [3 /*break*/, 3];
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WorkerDaemon.prototype.initializeWorkerStates = function () {
+        var _a, _b, _c, _d, _e;
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
             try {
-                const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
+                var 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 (((_a = saved.config) === null || _a === void 0 ? void 0 : _a.workers) && Array.isArray(saved.config.workers)) {
+                    var _loop_2 = function (savedWorker) {
+                        var workerConfig = this_2.config.workers.find(function (w) { return w.type === savedWorker.type; });
                         if (workerConfig && typeof savedWorker.enabled === 'boolean') {
                             workerConfig.enabled = savedWorker.enabled;
                         }
+                    };
+                    var this_2 = this;
+                    for (var _i = 0, _f = saved.config.workers; _i < _f.length; _i++) {
+                        var savedWorker = _f[_i];
+                        _loop_2(savedWorker);
+                    }
+                }
+                // Restore resourceThresholds, maxConcurrent, workerTimeoutMs from saved state
+                // Only restore if valid numeric values within sane ranges
+                if (((_b = saved.config) === null || _b === void 0 ? void 0 : _b.resourceThresholds) && !((_c = this.originalConfig) === null || _c === void 0 ? void 0 : _c.resourceThresholds)) {
+                    var 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 ((_d = saved.config) === null || _d === void 0 ? void 0 : _d.maxConcurrent) === 'number' && saved.config.maxConcurrent > 0) {
+                    this.config.maxConcurrent = saved.config.maxConcurrent;
+                }
+                if (typeof ((_e = saved.config) === null || _e === void 0 ? void 0 : _e.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;
-                        this.workers.set(type, {
+                    for (var _g = 0, _h = Object.entries(saved.workers); _g < _h.length; _g++) {
+                        var _j = _h[_g], type_1 = _j[0], state = _j[1];
+                        var savedState = state;
+                        var lastRunValue = savedState.lastRun;
+                        this.workers.set(type_1, {
                             runCount: savedState.runCount || 0,
                             successCount: savedState.successCount || 0,
                             failureCount: savedState.failureCount || 0,
                             averageDurationMs: savedState.averageDurationMs || 0,
                             lastRun: lastRunValue ? new Date(lastRunValue) : undefined,
                             nextRun: undefined,
-                            isRunning: false,
+                            isRunning: false
                         });
                     }
                 }
             }
-            catch {
+            catch (_k) {
                 // Ignore parse errors, start fresh
             }
         }
         // Initialize any missing workers
-        for (const workerConfig of this.config.workers) {
+        for (var _l = 0, _m = this.config.workers; _l < _m.length; _l++) {
+            var workerConfig = _m[_l];
             if (!this.workers.has(workerConfig.type)) {
                 this.workers.set(workerConfig.type, {
                     runCount: 0,
                     successCount: 0,
                     failureCount: 0,
                     averageDurationMs: 0,
-                    isRunning: false,
+                    isRunning: false
                 });
             }
         }
-    }
+    };
     /**
      * Start the daemon and all enabled workers
      */
-    async start() {
-        if (this.running) {
-            this.emit('warning', 'Daemon already running');
-            return;
-        }
-        this.running = true;
-        this.startedAt = new Date();
-        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);
-            }
-        }
-        // Save state
-        this.saveState();
-        this.log('info', `Daemon started with ${this.config.workers.filter(w => w.enabled).length} workers`);
-    }
+    WorkerDaemon.prototype.start = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _i, _a, workerConfig;
+            return __generator(this, function (_b) {
+                if (this.running) {
+                    this.emit('warning', 'Daemon already running');
+                    return [2 /*return*/];
+                }
+                this.running = true;
+                this.startedAt = new Date();
+                this.emit('started', { pid: process.pid, startedAt: this.startedAt });
+                // Schedule all enabled workers
+                for (_i = 0, _a = this.config.workers; _i < _a.length; _i++) {
+                    workerConfig = _a[_i];
+                    if (workerConfig.enabled) {
+                        this.scheduleWorker(workerConfig);
+                    }
+                }
+                // Save state
+                this.saveState();
+                this.log('info', "Daemon started (PID: " + process.pid + ", CPUs: " + cpus().length + ", workers: " + this.config.workers.filter(function (w) { return w.enabled; }).length + ", maxCpuLoad: " + this.config.resourceThresholds.maxCpuLoad + ", minFreeMemoryPercent: " + this.config.resourceThresholds.minFreeMemoryPercent + "%)");
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * 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();
-        this.running = false;
-        this.saveState();
-        this.emit('stopped', { stoppedAt: new Date() });
-        this.log('info', 'Daemon stopped');
-    }
+    WorkerDaemon.prototype.stop = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var timerEntries, _i, timerEntries_1, _a, type_2, timer;
+            return __generator(this, function (_b) {
+                if (!this.running) {
+                    this.emit('warning', 'Daemon not running');
+                    return [2 /*return*/];
+                }
+                timerEntries = Array.from(this.timers.entries());
+                for (_i = 0, timerEntries_1 = timerEntries; _i < timerEntries_1.length; _i++) {
+                    _a = timerEntries_1[_i], type_2 = _a[0], timer = _a[1];
+                    clearTimeout(timer);
+                    this.log('info', "Stopped worker: " + type_2);
+                }
+                this.timers.clear();
+                this.running = false;
+                this.saveState();
+                this.emit('stopped', { stoppedAt: new Date() });
+                this.log('info', 'Daemon stopped');
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Get daemon status
      */
-    getStatus() {
+    WorkerDaemon.prototype.getStatus = function () {
         return {
             running: this.running,
             pid: process.pid,
             startedAt: this.startedAt,
             workers: new Map(this.workers),
-            config: this.config,
+            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;
+    WorkerDaemon.prototype.scheduleWorker = function (workerConfig) {
+        var _this = this;
+        var state = this.workers.get(workerConfig.type);
+        var internalConfig = workerConfig;
+        var staggerOffset = internalConfig.offsetMs || 0;
         // Calculate initial delay with stagger offset
-        let initialDelay = staggerOffset;
+        var initialDelay = staggerOffset;
         if (state.lastRun) {
-            const timeSinceLastRun = Date.now() - state.lastRun.getTime();
+            var 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);
-            }
-        };
+        var runAndReschedule = function () { return __awaiter(_this, void 0, void 0, function () {
+            var timer_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.running)
+                            return [2 /*return*/];
+                        // Use concurrency-controlled execution (P0 fix)
+                        return [4 /*yield*/, this.executeWorkerWithConcurrencyControl(workerConfig)];
+                    case 1:
+                        // Use concurrency-controlled execution (P0 fix)
+                        _a.sent();
+                        // Reschedule
+                        if (this.running) {
+                            timer_1 = setTimeout(runAndReschedule, workerConfig.intervalMs);
+                            this.timers.set(workerConfig.type, timer_1);
+                            state.nextRun = new Date(Date.now() + workerConfig.intervalMs);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         // Schedule first run with stagger offset
-        const timer = setTimeout(runAndReschedule, initialDelay);
+        var 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)`);
-    }
+        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);
-    }
+    WorkerDaemon.prototype.executeWorkerWithConcurrencyControl = function (workerConfig) {
+        return __awaiter(this, void 0, Promise, function () {
+            var resourceCheck;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 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 [2 /*return*/, null];
+                        }
+                        return [4 /*yield*/, this.canRunWorker()];
+                    case 1:
+                        resourceCheck = _a.sent();
+                        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 [2 /*return*/, null];
+                        }
+                        return [2 /*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;
-        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)
-            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`);
-            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();
-        }
-    }
+    WorkerDaemon.prototype.executeWorker = function (workerConfig) {
+        return __awaiter(this, void 0, Promise, function () {
+            var state, workerId, startTime, output, durationMs, result, error_2, durationMs, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        state = this.workers.get(workerConfig.type);
+                        workerId = workerConfig.type + "_" + Date.now();
+                        startTime = Date.now();
+                        // Track running worker
+                        this.runningWorkers.add(workerConfig.type);
+                        state.isRunning = true;
+                        this.emit('worker:start', { workerId: workerId, type: workerConfig.type });
+                        this.log('info', "Starting worker: " + workerConfig.type + " (" + this.runningWorkers.size + "/" + this.config.maxConcurrent + " concurrent)");
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, this.runWithTimeout(function () { return _this.runWorkerLogic(workerConfig); }, this.config.workerTimeoutMs, "Worker " + workerConfig.type + " timed out after " + this.config.workerTimeoutMs / 1000 + "s", function () {
+                                // On timeout, cancel any headless execution to prevent orphan processes
+                                if (_this.headlessExecutor) {
+                                    _this.headlessExecutor.cancelAll();
+                                }
+                            })];
+                    case 2:
+                        output = _a.sent();
+                        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;
+                        result = {
+                            workerId: workerId,
+                            type: workerConfig.type,
+                            success: true,
+                            durationMs: durationMs,
+                            output: output,
+                            timestamp: new Date()
+                        };
+                        this.emit('worker:complete', result);
+                        this.log('info', "Worker " + workerConfig.type + " completed in " + durationMs + "ms");
+                        this.saveState();
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_2 = _a.sent();
+                        durationMs = Date.now() - startTime;
+                        state.runCount++;
+                        state.failureCount++;
+                        state.lastRun = new Date();
+                        state.isRunning = false;
+                        result = {
+                            workerId: workerId,
+                            type: workerConfig.type,
+                            success: false,
+                            durationMs: durationMs,
+                            error: error_2 instanceof Error ? error_2.message : String(error_2),
+                            timestamp: new Date()
+                        };
+                        this.emit('worker:error', result);
+                        this.log('error', "Worker " + workerConfig.type + " failed: " + result.error);
+                        this.saveState();
+                        return [2 /*return*/, result];
+                    case 4:
+                        // Remove from running set and process queue
+                        this.runningWorkers["delete"](workerConfig.type);
+                        this.processPendingWorkers();
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * 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) {
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                reject(new Error(timeoutMessage));
-            }, timeoutMs);
-            fn()
-                .then((result) => {
-                clearTimeout(timer);
-                resolve(result);
-            })
-                .catch((error) => {
-                clearTimeout(timer);
-                reject(error);
+    WorkerDaemon.prototype.runWithTimeout = function (fn, timeoutMs, timeoutMessage, onTimeout) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var settled = false;
+                        var timer = setTimeout(function () {
+                            if (settled)
+                                return;
+                            settled = true;
+                            // Kill orphan child processes before rejecting (#1117)
+                            if (onTimeout) {
+                                try {
+                                    onTimeout();
+                                }
+                                catch (_a) {
+                                    // Ignore cleanup errors
+                                }
+                            }
+                            reject(new Error(timeoutMessage));
+                        }, timeoutMs);
+                        fn()
+                            .then(function (result) {
+                            if (settled)
+                                return;
+                            settled = true;
+                            clearTimeout(timer);
+                            resolve(result);
+                        })["catch"](function (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);
-                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' };
-        }
-    }
+    WorkerDaemon.prototype.runWorkerLogic = function (workerConfig) {
+        return __awaiter(this, void 0, Promise, function () {
+            var result, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor)) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        this.log('info', "Running " + workerConfig.type + " in headless mode (Claude Code AI)");
+                        return [4 /*yield*/, this.headlessExecutor.execute(workerConfig.type)];
+                    case 2:
+                        result = _a.sent();
+                        return [2 /*return*/, __assign({ mode: 'headless' }, result)];
+                    case 3:
+                        error_3 = _a.sent();
+                        this.log('warn', "Headless execution failed for " + workerConfig.type + ", falling back to local mode");
+                        this.emit('headless:fallback', {
+                            type: workerConfig.type,
+                            error: error_3 instanceof Error ? error_3.message : String(error_3)
+                        });
+                        return [3 /*break*/, 4];
+                    case 4:
+                        // Local execution (fallback or for non-headless workers)
+                        switch (workerConfig.type) {
+                            case 'map':
+                                return [2 /*return*/, this.runMapWorker()];
+                            case 'audit':
+                                return [2 /*return*/, this.runAuditWorkerLocal()];
+                            case 'optimize':
+                                return [2 /*return*/, this.runOptimizeWorkerLocal()];
+                            case 'consolidate':
+                                return [2 /*return*/, this.runConsolidateWorker()];
+                            case 'testgaps':
+                                return [2 /*return*/, this.runTestGapsWorkerLocal()];
+                            case 'predict':
+                                return [2 /*return*/, this.runPredictWorkerLocal()];
+                            case 'document':
+                                return [2 /*return*/, this.runDocumentWorkerLocal()];
+                            case 'ultralearn':
+                                return [2 /*return*/, this.runUltralearnWorkerLocal()];
+                            case 'refactor':
+                                return [2 /*return*/, this.runRefactorWorkerLocal()];
+                            case 'deepdive':
+                                return [2 /*return*/, this.runDeepdiveWorkerLocal()];
+                            case 'benchmark':
+                                return [2 /*return*/, this.runBenchmarkWorkerLocal()];
+                            case 'preload':
+                                return [2 /*return*/, this.runPreloadWorkerLocal()];
+                            default:
+                                return [2 /*return*/, { status: 'unknown worker type', mode: 'local' }];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     // 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;
-    }
+    WorkerDaemon.prototype.runMapWorker = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var metricsFile, metricsDir, map;
+            return __generator(this, function (_a) {
+                metricsFile = join(this.projectRoot, '.claude-flow', 'metrics', 'codebase-map.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                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 [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;
-    }
+    WorkerDaemon.prototype.runAuditWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var auditFile, metricsDir, audit;
+            return __generator(this, function (_a) {
+                auditFile = join(this.projectRoot, '.claude-flow', 'metrics', 'security-audit.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                audit = {
+                    timestamp: new Date().toISOString(),
+                    mode: 'local',
+                    checks: {
+                        envFilesProtected: !existsSync(join(this.projectRoot, '.env.local')),
+                        gitIgnoreExists: existsSync(join(this.projectRoot, '.gitignore')),
+                        noHardcodedSecrets: true
+                    },
+                    riskLevel: 'low',
+                    recommendations: [],
+                    note: 'Install Claude Code CLI for AI-powered security analysis'
+                };
+                writeFileSync(auditFile, JSON.stringify(audit, null, 2));
+                return [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;
-    }
+    WorkerDaemon.prototype.runOptimizeWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var optimizeFile, metricsDir, perf;
+            return __generator(this, function (_a) {
+                optimizeFile = join(this.projectRoot, '.claude-flow', 'metrics', 'performance.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                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 [2 /*return*/, perf];
+            });
+        });
+    };
+    WorkerDaemon.prototype.runConsolidateWorker = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var consolidateFile, metricsDir, result;
+            return __generator(this, function (_a) {
+                consolidateFile = join(this.projectRoot, '.claude-flow', 'metrics', 'consolidation.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                result = {
+                    timestamp: new Date().toISOString(),
+                    patternsConsolidated: 0,
+                    memoryCleaned: 0,
+                    duplicatesRemoved: 0
+                };
+                writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
+                return [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;
-    }
+    WorkerDaemon.prototype.runTestGapsWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var testGapsFile, metricsDir, result;
+            return __generator(this, function (_a) {
+                testGapsFile = join(this.projectRoot, '.claude-flow', 'metrics', 'test-gaps.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                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 [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',
-        };
-    }
+    WorkerDaemon.prototype.runPredictWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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',
-        };
-    }
+    WorkerDaemon.prototype.runDocumentWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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',
-        };
-    }
+    WorkerDaemon.prototype.runUltralearnWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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',
-        };
-    }
+    WorkerDaemon.prototype.runRefactorWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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',
-        };
-    }
+    WorkerDaemon.prototype.runDeepdiveWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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;
-    }
+    WorkerDaemon.prototype.runBenchmarkWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var benchmarkFile, metricsDir, result;
+            return __generator(this, function (_a) {
+                benchmarkFile = join(this.projectRoot, '.claude-flow', 'metrics', 'benchmark.json');
+                metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+                if (!existsSync(metricsDir)) {
+                    mkdirSync(metricsDir, { recursive: true });
+                }
+                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 [2 /*return*/, result];
+            });
+        });
+    };
     /**
      * Local preload worker
      */
-    async runPreloadWorkerLocal() {
-        return {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            resourcesPreloaded: 0,
-            cacheStatus: 'active',
-        };
-    }
+    WorkerDaemon.prototype.runPreloadWorkerLocal = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*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);
-    }
+    WorkerDaemon.prototype.triggerWorker = function (type) {
+        return __awaiter(this, void 0, Promise, function () {
+            var workerConfig;
+            return __generator(this, function (_a) {
+                workerConfig = this.config.workers.find(function (w) { return w.type === type; });
+                if (!workerConfig) {
+                    throw new Error("Unknown worker type: " + type);
+                }
+                return [2 /*return*/, this.executeWorker(workerConfig)];
+            });
+        });
+    };
     /**
      * Enable/disable a worker
      */
-    setWorkerEnabled(type, enabled) {
-        const workerConfig = this.config.workers.find(w => w.type === type);
+    WorkerDaemon.prototype.setWorkerEnabled = function (type, enabled) {
+        var workerConfig = this.config.workers.find(function (w) { return w.type === type; });
         if (workerConfig) {
             workerConfig.enabled = enabled;
             if (enabled && this.running) {
                 this.scheduleWorker(workerConfig);
             }
             else if (!enabled) {
-                const timer = this.timers.get(type);
+                var timer = this.timers.get(type);
                 if (timer) {
                     clearTimeout(timer);
-                    this.timers.delete(type);
+                    this.timers["delete"](type);
                 }
             }
             this.saveState();
         }
-    }
+    };
     /**
      * Save daemon state to file
      */
-    saveState() {
-        const state = {
+    WorkerDaemon.prototype.saveState = function () {
+        var _a;
+        var 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(),
-                    nextRun: state.nextRun?.toISOString(),
-                }
-            ])),
-            config: {
-                ...this.config,
-                workers: this.config.workers.map(w => ({ ...w })),
-            },
-            savedAt: new Date().toISOString(),
+            startedAt: (_a = this.startedAt) === null || _a === void 0 ? void 0 : _a.toISOString(),
+            workers: Object.fromEntries(Array.from(this.workers.entries()).map(function (_a) {
+                var _b, _c;
+                var type = _a[0], state = _a[1];
+                return [
+                    type,
+                    __assign(__assign({}, state), { lastRun: (_b = state.lastRun) === null || _b === void 0 ? void 0 : _b.toISOString(), nextRun: (_c = state.nextRun) === null || _c === void 0 ? void 0 : _c.toISOString() })
+                ];
+            })),
+            config: __assign(__assign({}, this.config), { workers: this.config.workers.map(function (w) { return (__assign({}, w)); }) }),
+            savedAt: new Date().toISOString()
         };
         try {
             writeFileSync(this.config.stateFile, JSON.stringify(state, null, 2));
         }
         catch (error) {
-            this.log('error', `Failed to save state: ${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 });
+    WorkerDaemon.prototype.log = function (level, message) {
+        var timestamp = new Date().toISOString();
+        var logMessage = "[" + timestamp + "] [" + level.toUpperCase() + "] " + message;
+        this.emit('log', { level: level, message: message, timestamp: timestamp });
         // Also write to log file
         try {
-            const logFile = join(this.config.logDir, 'daemon.log');
-            const fs = require('fs');
-            fs.appendFileSync(logFile, logMessage + '\n');
+            var logFile = join(this.config.logDir, 'daemon.log');
+            appendFileSync(logFile, logMessage + '\n');
         }
-        catch {
+        catch (_a) {
             // Ignore log write errors
         }
-    }
-}
+    };
+    return WorkerDaemon;
+}(EventEmitter));
+export { WorkerDaemon };
 // Singleton instance for global access
-let daemonInstance = null;
+var daemonInstance = null;
 /**
  * Get or create daemon instance
  */
-export function getDaemon(projectRoot) {
+export function getDaemon(projectRoot, config) {
     if (!daemonInstance && projectRoot) {
-        daemonInstance = new WorkerDaemon(projectRoot);
+        daemonInstance = new WorkerDaemon(projectRoot, config);
     }
     if (!daemonInstance) {
         throw new Error('Daemon not initialized. Provide projectRoot on first call.');
@@ -739,18 +1116,38 @@ export function getDaemon(projectRoot) {
 /**
  * Start daemon (for use in session-start hook)
  */
-export async function startDaemon(projectRoot) {
-    const daemon = getDaemon(projectRoot);
-    await daemon.start();
-    return daemon;
+export function startDaemon(projectRoot, config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var daemon;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    daemon = getDaemon(projectRoot, config);
+                    return [4 /*yield*/, daemon.start()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, daemon];
+            }
+        });
+    });
 }
 /**
  * Stop daemon
  */
-export async function stopDaemon() {
-    if (daemonInstance) {
-        await daemonInstance.stop();
-    }
+export function stopDaemon() {
+    return __awaiter(this, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!daemonInstance) return [3 /*break*/, 2];
+                    return [4 /*yield*/, daemonInstance.stop()];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
+            }
+        });
+    });
 }
 export default WorkerDaemon;
 //# sourceMappingURL=worker-daemon.js.map