kynjal-cli 4.0.0 → 4.0.1

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

@@ -9,75 +9,13 @@
  * - 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, 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)
-var DEFAULT_WORKERS = [
+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 },
@@ -87,127 +25,116 @@ var DEFAULT_WORKERS = [
     { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
 ];
 // Worker timeout (5 minutes max per worker)
-var DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;
 /**
  * Worker Daemon - Manages background workers with Node.js
  */
-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');
+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;
+    // 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)
-        var fileConfig = _this.readDaemonConfigFromFile(claudeFlowDir);
+        const 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
+        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.
-        var defaultMinFreeMemory = process.platform === 'darwin' ? 5 : 10;
+        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: (_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,
+        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: (_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
+                maxCpuLoad: config?.resourceThresholds?.maxCpuLoad ?? fileConfig.maxCpuLoad ?? smartMaxCpuLoad,
+                minFreeMemoryPercent: config?.resourceThresholds?.minFreeMemoryPercent ?? fileConfig.minFreeMemoryPercent ?? defaultMinFreeMemory,
             },
-            workers: (_q = config === null || config === void 0 ? void 0 : config.workers) !== null && _q !== void 0 ? _q : DEFAULT_WORKERS
+            workers: config?.workers ?? 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"](function (err) {
-            _this.log('warn', "Headless executor init failed: " + err);
+        this.initHeadlessExecutor().catch((err) => {
+            this.log('warn', `Headless executor init failed: ${err}`);
         });
-        return _this;
     }
     /**
      * Initialize headless executor if Claude Code is available
      */
-    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*/];
-                }
+    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
+                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
      */
-    WorkerDaemon.prototype.isHeadlessAvailable = function () {
+    isHeadlessAvailable() {
         return this.headlessAvailable;
-    };
+    }
     /**
      * Get headless executor instance
      */
-    WorkerDaemon.prototype.getHeadlessExecutor = function () {
+    getHeadlessExecutor() {
         return this.headlessExecutor;
-    };
+    }
     /**
      * Detect effective CPU count for the current environment.
      *
@@ -216,107 +143,88 @@ var WorkerDaemon = /** @class */ (function (_super) {
      * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
      * meaningful under resource-limited containers.
      */
-    WorkerDaemon.getEffectiveCpuCount = function () {
+    static getEffectiveCpuCount() {
         // 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];
+            const cpuMax = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim();
+            const [quotaStr, periodStr] = cpuMax.split(' ');
             if (quotaStr !== 'max') {
-                var quota = parseInt(quotaStr, 10);
-                var period = parseInt(periodStr, 10);
+                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 */_b) { /* not in cgroup v2 */ }
+        catch { /* 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);
+            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 */_c) { /* not in cgroup v1 */ }
+        catch { /* 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');
+    readDaemonConfigFromFile(claudeFlowDir) {
+        const configPath = join(claudeFlowDir, 'config.json');
         if (!existsSync(configPath))
             return {};
         try {
-            var raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            const 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'];
+            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
+                minFreeMemoryPercent: (typeof rawMinMem === 'number' && rawMinMem >= 0 && rawMinMem <= 100) ? rawMinMem : undefined,
             };
         }
-        catch (_g) {
+        catch {
             return {};
         }
-    };
+    }
     /**
      * Setup graceful shutdown handlers
      */
-    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*/];
-                }
-            });
-        }); };
+    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);
-    };
+    }
     /**
      * Check if system resources allow worker execution
      */
-    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 }];
-                }
-            });
-        });
-    };
+    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
      *
@@ -326,80 +234,45 @@ var WorkerDaemon = /** @class */ (function (_super) {
      * currently running when we break, we schedule a backoff retry so the queue
      * does not get permanently stuck.
      */
-    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*/];
+    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;
                 }
-            });
-        });
-    };
-    WorkerDaemon.prototype.initializeWorkerStates = function () {
-        var _a, _b, _c, _d, _e;
+            }
+        }
+    }
+    initializeWorkerStates() {
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
             try {
-                var saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
+                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 (((_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 (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;
                         }
-                    };
-                    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 (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;
                     }
@@ -407,263 +280,217 @@ var WorkerDaemon = /** @class */ (function (_super) {
                         this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
                     }
                 }
-                if (typeof ((_d = saved.config) === null || _d === void 0 ? void 0 : _d.maxConcurrent) === 'number' && saved.config.maxConcurrent > 0) {
+                if (typeof saved.config?.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) {
+                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 (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, {
+                    for (const [type, state] of Object.entries(saved.workers)) {
+                        const savedState = state;
+                        const lastRunValue = savedState.lastRun;
+                        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,
                             nextRun: undefined,
-                            isRunning: false
+                            isRunning: false,
                         });
                     }
                 }
             }
-            catch (_k) {
+            catch {
                 // Ignore parse errors, start fresh
             }
         }
         // Initialize any missing workers
-        for (var _l = 0, _m = this.config.workers; _l < _m.length; _l++) {
-            var workerConfig = _m[_l];
+        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
+                    isRunning: false,
                 });
             }
         }
-    };
+    }
     /**
      * Start the daemon and all enabled 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*/];
-            });
-        });
-    };
+    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 (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}%)`);
+    }
     /**
      * Stop the daemon and all workers
      */
-    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*/];
-            });
-        });
-    };
+    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');
+    }
     /**
      * Get daemon status
      */
-    WorkerDaemon.prototype.getStatus = function () {
+    getStatus() {
         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
      */
-    WorkerDaemon.prototype.scheduleWorker = function (workerConfig) {
-        var _this = this;
-        var state = this.workers.get(workerConfig.type);
-        var internalConfig = workerConfig;
-        var staggerOffset = internalConfig.offsetMs || 0;
+    scheduleWorker(workerConfig) {
+        const state = this.workers.get(workerConfig.type);
+        const internalConfig = workerConfig;
+        const staggerOffset = internalConfig.offsetMs || 0;
         // Calculate initial delay with stagger offset
-        var initialDelay = staggerOffset;
+        let initialDelay = staggerOffset;
         if (state.lastRun) {
-            var timeSinceLastRun = Date.now() - state.lastRun.getTime();
+            const timeSinceLastRun = Date.now() - state.lastRun.getTime();
             initialDelay = Math.max(staggerOffset, workerConfig.intervalMs - timeSinceLastRun);
         }
         state.nextRun = new Date(Date.now() + initialDelay);
-        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*/];
-                }
-            });
-        }); };
+        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
-        var timer = setTimeout(runAndReschedule, initialDelay);
+        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)");
-    };
+        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)
      */
-    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)];
-                }
-            });
-        });
-    };
+    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
      */
-    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*/];
+    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)
+            // 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
@@ -671,436 +498,371 @@ var WorkerDaemon = /** @class */ (function (_super) {
      * @param timeoutMessage - Error message on timeout
      * @param onTimeout - Optional cleanup callback invoked when timeout fires (#1117: kills orphan processes)
      */
-    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);
-                        });
-                    })];
+    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
      */
-    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
-    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()
+    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,
                 };
-                writeFileSync(metricsFile, JSON.stringify(map, null, 2));
-                return [2 /*return*/, map];
-            });
-        });
-    };
+            }
+            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' };
+        }
+    }
+    // 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)
      */
-    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];
-            });
-        });
-    };
+    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)
      */
-    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];
-            });
-        });
-    };
+    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)
      */
-    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];
-            });
-        });
-    };
+    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)
      */
-    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'
-                    }];
-            });
-        });
-    };
+    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)
      */
-    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'
-                    }];
-            });
-        });
-    };
+    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)
      */
-    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'
-                    }];
-            });
-        });
-    };
+    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)
      */
-    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'
-                    }];
-            });
-        });
-    };
+    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)
      */
-    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'
-                    }];
-            });
-        });
-    };
+    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
      */
-    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];
-            });
-        });
-    };
+    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
      */
-    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'
-                    }];
-            });
-        });
-    };
+    async runPreloadWorkerLocal() {
+        return {
+            timestamp: new Date().toISOString(),
+            mode: 'local',
+            resourcesPreloaded: 0,
+            cacheStatus: 'active',
+        };
+    }
     /**
      * Manually trigger a worker
      */
-    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)];
-            });
-        });
-    };
+    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
      */
-    WorkerDaemon.prototype.setWorkerEnabled = function (type, enabled) {
-        var workerConfig = this.config.workers.find(function (w) { return w.type === type; });
+    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) {
-                var timer = this.timers.get(type);
+                const timer = this.timers.get(type);
                 if (timer) {
                     clearTimeout(timer);
-                    this.timers["delete"](type);
+                    this.timers.delete(type);
                 }
             }
             this.saveState();
         }
-    };
+    }
     /**
      * Save daemon state to file
      */
-    WorkerDaemon.prototype.saveState = function () {
-        var _a;
-        var state = {
+    saveState() {
+        const state = {
             running: this.running,
-            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()
+            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(),
         };
         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
      */
-    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 });
+    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 {
-            var logFile = join(this.config.logDir, 'daemon.log');
+            const logFile = join(this.config.logDir, 'daemon.log');
             appendFileSync(logFile, logMessage + '\n');
         }
-        catch (_a) {
+        catch {
             // Ignore log write errors
         }
-    };
-    return WorkerDaemon;
-}(EventEmitter));
-export { WorkerDaemon };
+    }
+}
 // Singleton instance for global access
-var daemonInstance = null;
+let daemonInstance = null;
 /**
  * Get or create daemon instance
  */
@@ -1116,38 +878,18 @@ export function getDaemon(projectRoot, config) {
 /**
  * Start daemon (for use in session-start hook)
  */
-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];
-            }
-        });
-    });
+export async function startDaemon(projectRoot, config) {
+    const daemon = getDaemon(projectRoot, config);
+    await daemon.start();
+    return daemon;
 }
 /**
  * Stop daemon
  */
-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 async function stopDaemon() {
+    if (daemonInstance) {
+        await daemonInstance.stop();
+    }
 }
 export default WorkerDaemon;
 //# sourceMappingURL=worker-daemon.js.map