monomind 1.19.0 → 2.0.1

package/packages/@monomind/cli/dist/src/services/worker-daemon.js

@@ -1,1350 +0,0 @@
-/**
- * Worker Daemon Service
- * Node.js-based background worker system that auto-runs like shell daemons
- *
- * Workers:
- * - map: Codebase mapping (5 min interval)
- * - audit: Security analysis (10 min interval)
- * - optimize: Performance optimization (15 min interval)
- * - consolidate: Memory consolidation (30 min interval)
- * - testgaps, predict, document, refactor, preload: no local-mode
- *   implementation — real work only happens in headless mode via
- *   HeadlessWorkerExecutor (Claude Code CLI required)
- */
-import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
-import { cpus } from 'os';
-import { join, resolve } from 'path';
-import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
-// Default worker configurations with improved intervals (P0 fix: map 5min -> 15min)
-const DEFAULT_WORKERS = [
-    { type: 'map', intervalMs: 15 * 60 * 1000, offsetMs: 0, priority: 'normal', description: 'Codebase mapping', enabled: true },
-    { type: 'audit', intervalMs: 10 * 60 * 1000, offsetMs: 2 * 60 * 1000, priority: 'critical', description: 'Security analysis', enabled: true },
-    { type: 'optimize', intervalMs: 15 * 60 * 1000, offsetMs: 4 * 60 * 1000, priority: 'high', description: 'Performance optimization', enabled: true },
-    { type: 'consolidate', intervalMs: 30 * 60 * 1000, offsetMs: 6 * 60 * 1000, priority: 'low', description: 'Memory consolidation', enabled: true },
-    { type: 'testgaps', intervalMs: 20 * 60 * 1000, offsetMs: 8 * 60 * 1000, priority: 'normal', description: 'Test coverage analysis', enabled: true },
-    { type: 'predict', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Predictive preloading', enabled: false },
-    { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
-];
-// Worker timeout — must exceed the longest per-worker headless timeout (15 min for audit/refactor).
-// Previously 5 min, which caused orphan processes when daemon timeout fired before executor timeout (#1117).
-const DEFAULT_WORKER_TIMEOUT_MS = 16 * 60 * 1000;
-/**
- * Worker Daemon - Manages background workers with Node.js
- */
-export class WorkerDaemon extends EventEmitter {
-    config;
-    workers = new Map();
-    timers = new Map();
-    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();
-        // Resolve and validate projectRoot. Without this an attacker who can pass
-        // a crafted projectRoot (env var, untrusted CLI flag, MCP tool argument)
-        // gets arbitrary file write via the derived pidFile, logFile, stateFile,
-        // and metrics paths.
-        const resolved = resolve(projectRoot);
-        this.projectRoot = resolved;
-        this.originalConfig = config;
-        const monomindDir = join(resolved, '.monomind');
-        // Read daemon config from .monomind/config.json (Layer B)
-        const fileConfig = this.readDaemonConfigFromFile(monomindDir);
-        // CPU-proportional smart default instead of hardcoded 2.0
-        const cpuCount = WorkerDaemon.getEffectiveCpuCount();
-        const smartMaxCpuLoad = Math.max(cpuCount * 0.8, 2.0); // Floor of 2.0 for single-CPU machines
-        // Platform-aware default: macOS os.freemem() excludes reclaimable file cache,
-        // so reported "free" is much lower than actually available memory.
-        // Linux reports available memory (including reclaimable cache) more accurately.
-        const defaultMinFreeMemory = process.platform === 'darwin' ? 5 : 10;
-        // Priority: constructor arg > config.json > smart default
-        // For resourceThresholds, merge field-by-field so partial overrides
-        // (e.g. only --max-cpu-load) still pick up defaults for other fields.
-        this.config = {
-            autoStart: config?.autoStart ?? fileConfig.autoStart ?? false,
-            logDir: config?.logDir ?? join(monomindDir, 'logs'),
-            stateFile: config?.stateFile ?? join(monomindDir, 'daemon-state.json'),
-            maxConcurrent: config?.maxConcurrent ?? fileConfig.maxConcurrent ?? 2,
-            workerTimeoutMs: config?.workerTimeoutMs ?? fileConfig.workerTimeoutMs ?? DEFAULT_WORKER_TIMEOUT_MS,
-            resourceThresholds: {
-                maxCpuLoad: config?.resourceThresholds?.maxCpuLoad ?? fileConfig.maxCpuLoad ?? smartMaxCpuLoad,
-                minFreeMemoryPercent: config?.resourceThresholds?.minFreeMemoryPercent ?? fileConfig.minFreeMemoryPercent ?? defaultMinFreeMemory,
-            },
-            workers: config?.workers ?? DEFAULT_WORKERS,
-        };
-        // Setup graceful shutdown handlers
-        this.setupShutdownHandlers();
-        // Ensure directories exist
-        if (!existsSync(monomindDir)) {
-            mkdirSync(monomindDir, { recursive: true });
-        }
-        if (!existsSync(this.config.logDir)) {
-            mkdirSync(this.config.logDir, { recursive: true });
-        }
-        // Initialize worker states
-        this.initializeWorkerStates();
-        // Initialize headless executor (async, non-blocking)
-        this.initHeadlessExecutor().catch((err) => {
-            this.log('warn', `Headless executor init failed: ${err}`);
-        });
-    }
-    /**
-     * Initialize headless executor if Claude Code is available
-     */
-    async initHeadlessExecutor() {
-        try {
-            this.headlessExecutor = new HeadlessWorkerExecutor(this.projectRoot, {
-                maxConcurrent: this.config.maxConcurrent,
-            });
-            this.headlessAvailable = await this.headlessExecutor.isAvailable();
-            if (this.headlessAvailable) {
-                this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events.
-                // The executor emits 'start', 'complete', 'error' (not 'execution:*').
-                this.headlessExecutor.on('start', (data) => {
-                    this.emit('headless:start', data);
-                });
-                this.headlessExecutor.on('complete', (data) => {
-                    this.emit('headless:complete', data);
-                });
-                this.headlessExecutor.on('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() {
-        return this.headlessAvailable;
-    }
-    /**
-     * Get headless executor instance
-     */
-    getHeadlessExecutor() {
-        return this.headlessExecutor;
-    }
-    /**
-     * Detect effective CPU count for the current environment.
-     *
-     * Inside Docker / K8s containers, os.cpus().length reports the HOST cpu
-     * count, not the container limit (Node.js #28762 — wontfix).  We read
-     * cgroup v2 / v1 quota files first so the maxCpuLoad threshold stays
-     * meaningful under resource-limited containers.
-     */
-    static getEffectiveCpuCount() {
-        // 1. Try cgroup v2: /sys/fs/cgroup/cpu.max
-        try {
-            const cpuMax = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim();
-            const [quotaStr, periodStr] = cpuMax.split(' ');
-            if (quotaStr !== 'max') {
-                const quota = parseInt(quotaStr, 10);
-                const period = parseInt(periodStr, 10);
-                if (quota > 0 && period > 0)
-                    return Math.ceil(quota / period);
-            }
-        }
-        catch { /* not in cgroup v2 */ }
-        // 2. Try cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us
-        try {
-            const quota = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf8').trim(), 10);
-            const period = parseInt(readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf8').trim(), 10);
-            if (quota > 0 && period > 0)
-                return Math.ceil(quota / period);
-        }
-        catch { /* not in cgroup v1 */ }
-        // 3. Fallback to os.cpus().length
-        return cpus().length || 1;
-    }
-    /**
-     * Read daemon-specific config from .monomind/config.json
-     * Supports dot-notation keys like 'daemon.resourceThresholds.maxCpuLoad'
-     */
-    readDaemonConfigFromFile(monomindDir) {
-        const configPath = join(monomindDir, 'config.json');
-        if (!existsSync(configPath)) {
-            // Warn if config.yaml exists but config.json does not (#1395 Bug 4)
-            const yamlPath = join(monomindDir, 'config.yaml');
-            const ymlPath = join(monomindDir, 'config.yml');
-            if (existsSync(yamlPath) || existsSync(ymlPath)) {
-                this.log('warn', `Found ${existsSync(yamlPath) ? 'config.yaml' : 'config.yml'} but daemon reads only config.json — YAML config is being ignored. Convert to JSON or create config.json.`);
-            }
-            return {};
-        }
-        try {
-            // Guard against OOM from an oversized config file (tampered or corrupted).
-            const configSize = statSync(configPath).size;
-            if (configSize > 1_048_576 /* 1 MB */) {
-                this.log('warn', `config.json is unusually large (${configSize} bytes) — ignoring daemon config`);
-                return {};
-            }
-            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
-            // Support both flat keys at root and nested under scopes.project
-            const cfg = raw?.scopes?.project ?? raw;
-            const rawCpuLoad = cfg['daemon.resourceThresholds.maxCpuLoad'] ?? raw['daemon.resourceThresholds.maxCpuLoad'];
-            const rawMinMem = cfg['daemon.resourceThresholds.minFreeMemoryPercent'] ?? raw['daemon.resourceThresholds.minFreeMemoryPercent'];
-            const rawMaxConcurrent = cfg['daemon.maxConcurrent'] ?? raw['daemon.maxConcurrent'];
-            const rawTimeout = cfg['daemon.workerTimeoutMs'] ?? raw['daemon.workerTimeoutMs'];
-            return {
-                autoStart: typeof raw['daemon.autoStart'] === 'boolean' ? raw['daemon.autoStart'] : undefined,
-                maxConcurrent: (typeof rawMaxConcurrent === 'number' && rawMaxConcurrent > 0) ? rawMaxConcurrent : undefined,
-                workerTimeoutMs: (typeof rawTimeout === 'number' && rawTimeout > 0) ? rawTimeout : undefined,
-                maxCpuLoad: (typeof rawCpuLoad === 'number' && rawCpuLoad > 0 && rawCpuLoad < 1000) ? rawCpuLoad : undefined,
-                minFreeMemoryPercent: (typeof rawMinMem === 'number' && rawMinMem >= 0 && rawMinMem <= 100) ? rawMinMem : undefined,
-            };
-        }
-        catch {
-            return {};
-        }
-    }
-    /**
-     * Setup graceful shutdown handlers
-     */
-    setupShutdownHandlers() {
-        const shutdown = async () => {
-            this.log('info', 'Received shutdown signal, stopping daemon...');
-            await this.stop();
-            process.exit(0);
-        };
-        process.once('SIGTERM', shutdown);
-        process.once('SIGINT', shutdown);
-        process.once('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 };
-    }
-    /**
-     * Process pending workers queue
-     *
-     * When executeWorkerWithConcurrencyControl defers a worker (returns null),
-     * we break immediately to avoid a busy-wait loop — the deferred worker is
-     * already back on the pendingWorkers queue by that point. If no workers are
-     * currently running when we break, we schedule a backoff retry so the queue
-     * does not get permanently stuck.
-     */
-    async processPendingWorkers() {
-        while (this.pendingWorkers.length > 0 && this.runningWorkers.size < this.config.maxConcurrent) {
-            const workerType = this.pendingWorkers.shift();
-            const workerConfig = this.config.workers.find(w => w.type === workerType);
-            if (workerConfig) {
-                const result = await this.executeWorkerWithConcurrencyControl(workerConfig);
-                if (result === null) {
-                    // Worker was deferred (resource pressure or concurrency limit).
-                    // Break to avoid tight-looping — the next executeWorker() completion
-                    // will call processPendingWorkers() again via the finally block.
-                    if (this.runningWorkers.size === 0) {
-                        // No workers running means nobody will trigger the finally-block
-                        // callback, so schedule a backoff retry to avoid a stuck queue.
-                        setTimeout(() => this.processPendingWorkers(), 30_000).unref();
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    initializeWorkerStates() {
-        // Try to restore state from file
-        if (existsSync(this.config.stateFile)) {
-            try {
-                // Guard against OOM from an oversized state file (tampered or corrupted).
-                const stateSize = statSync(this.config.stateFile).size;
-                if (stateSize > 5_242_880 /* 5 MB */) {
-                    this.log('warn', `daemon-state.json is unusually large (${stateSize} bytes) — starting with fresh state`);
-                    return;
-                }
-                const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
-                // CRITICAL: Restore worker config (including enabled flag) from saved state
-                // This fixes #950: daemon enable command not persisting worker state
-                if (saved.config?.workers && Array.isArray(saved.config.workers)) {
-                    for (const savedWorker of saved.config.workers) {
-                        const workerConfig = this.config.workers.find(w => w.type === savedWorker.type);
-                        if (workerConfig && typeof savedWorker.enabled === 'boolean') {
-                            workerConfig.enabled = savedWorker.enabled;
-                        }
-                    }
-                }
-                // Restore resourceThresholds, maxConcurrent, workerTimeoutMs from saved state
-                // Only restore if valid numeric values within sane ranges
-                if (saved.config?.resourceThresholds && !this.originalConfig?.resourceThresholds) {
-                    const rt = saved.config.resourceThresholds;
-                    if (typeof rt.maxCpuLoad === 'number' && rt.maxCpuLoad > 0 && rt.maxCpuLoad < 1000) {
-                        this.config.resourceThresholds.maxCpuLoad = rt.maxCpuLoad;
-                    }
-                    if (typeof rt.minFreeMemoryPercent === 'number' && rt.minFreeMemoryPercent >= 0 && rt.minFreeMemoryPercent <= 100) {
-                        this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
-                    }
-                }
-                if (typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
-                    this.config.maxConcurrent = saved.config.maxConcurrent;
-                }
-                if (typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
-                    this.config.workerTimeoutMs = saved.config.workerTimeoutMs;
-                }
-                // Restore worker runtime states (runCount, successCount, etc.)
-                // Validate keys against an allowlist to defeat prototype-pollution
-                // attempts and reject unknown worker types injected into the file.
-                if (saved.workers && typeof saved.workers === 'object') {
-                    const VALID_TYPES = new Set(this.config.workers.map(w => w.type));
-                    const FORBIDDEN = new Set(['__proto__', 'constructor', 'prototype']);
-                    const finiteNonNeg = (v) => {
-                        if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
-                            return 0;
-                        return Math.floor(v);
-                    };
-                    for (const [type, state] of Object.entries(saved.workers)) {
-                        if (FORBIDDEN.has(type) || !VALID_TYPES.has(type))
-                            continue;
-                        const savedState = state;
-                        const lastRunValue = savedState.lastRun;
-                        const lastRunDate = typeof lastRunValue === 'string' ? new Date(lastRunValue) : undefined;
-                        this.workers.set(type, {
-                            runCount: finiteNonNeg(savedState.runCount),
-                            successCount: finiteNonNeg(savedState.successCount),
-                            failureCount: finiteNonNeg(savedState.failureCount),
-                            averageDurationMs: finiteNonNeg(savedState.averageDurationMs),
-                            lastRun: lastRunDate && !isNaN(lastRunDate.getTime()) ? lastRunDate : undefined,
-                            nextRun: undefined,
-                            isRunning: false,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignore parse errors, start fresh
-            }
-        }
-        // Initialize any missing workers
-        for (const workerConfig of this.config.workers) {
-            if (!this.workers.has(workerConfig.type)) {
-                this.workers.set(workerConfig.type, {
-                    runCount: 0,
-                    successCount: 0,
-                    failureCount: 0,
-                    averageDurationMs: 0,
-                    isRunning: false,
-                });
-            }
-        }
-    }
-    /**
-     * Get the PID file path for singleton enforcement (#1395 Bug 3).
-     */
-    get pidFile() {
-        return join(this.projectRoot, '.monomind', 'daemon.pid');
-    }
-    /**
-     * Check if another daemon instance is already running.
-     * Returns the existing PID if alive, or null if no daemon is running.
-     */
-    checkExistingDaemon() {
-        if (!existsSync(this.pidFile))
-            return null;
-        try {
-            const pid = parseInt(readFileSync(this.pidFile, 'utf-8').trim(), 10);
-            if (isNaN(pid))
-                return null;
-            // Check if process is alive (signal 0 = existence check)
-            process.kill(pid, 0);
-            return pid; // Process is alive
-        }
-        catch {
-            // Process is dead — clean up stale PID file
-            try {
-                unlinkSync(this.pidFile);
-            }
-            catch { /* ignore */ }
-            return null;
-        }
-    }
-    /**
-     * Write PID file with O_EXCL for atomic singleton enforcement (closes the
-     * TOCTOU window between checkExistingDaemon and writePidFile that previously
-     * allowed two concurrent `daemon start` calls to both succeed).
-     * Returns true on success, false if another daemon raced us.
-     */
-    writePidFile() {
-        const dir = join(this.projectRoot, '.monomind');
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        try {
-            // wx flag = O_CREAT | O_EXCL — atomic create-or-fail
-            writeFileSync(this.pidFile, String(process.pid), { flag: 'wx' });
-            return true;
-        }
-        catch (e) {
-            const code = e.code;
-            if (code === 'EEXIST') {
-                // Recheck liveness — file may belong to a dead daemon we missed
-                const racePid = this.checkExistingDaemon();
-                if (racePid === null) {
-                    // Stale file was just removed by checkExistingDaemon, retry once
-                    try {
-                        writeFileSync(this.pidFile, String(process.pid), { flag: 'wx' });
-                        return true;
-                    }
-                    catch {
-                        return false;
-                    }
-                }
-                return false;
-            }
-            throw e;
-        }
-    }
-    /**
-     * Remove PID file on shutdown.
-     */
-    removePidFile() {
-        try {
-            unlinkSync(this.pidFile);
-        }
-        catch { /* ignore */ }
-    }
-    /**
-     * Start the daemon and all enabled workers
-     */
-    async start() {
-        if (this.running) {
-            this.emit('warning', 'Daemon already running');
-            return;
-        }
-        // PID singleton enforcement (#1395 Bug 3): prevent daemon accumulation
-        const existingPid = this.checkExistingDaemon();
-        if (existingPid !== null) {
-            this.log('info', `Daemon already running (PID: ${existingPid}), skipping start`);
-            this.emit('warning', `Daemon already running (PID: ${existingPid})`);
-            return;
-        }
-        // Atomic PID file write — fails if another daemon raced us past
-        // checkExistingDaemon. Without this two `daemon start` calls could both
-        // pass the existence check then both clobber the PID file.
-        if (!this.writePidFile()) {
-            this.log('info', 'Another daemon won the PID race — aborting start');
-            this.emit('warning', 'Another daemon instance is starting/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
-     */
-    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.removePidFile();
-        this.saveState();
-        this.emit('stopped', { stoppedAt: new Date() });
-        this.log('info', 'Daemon stopped');
-    }
-    /**
-     * Get daemon status
-     */
-    getStatus() {
-        return {
-            running: this.running,
-            pid: process.pid,
-            startedAt: this.startedAt,
-            workers: new Map(this.workers),
-            config: this.config,
-        };
-    }
-    /**
-     * Schedule a worker to run at intervals with staggered start
-     */
-    scheduleWorker(workerConfig) {
-        const state = this.workers.get(workerConfig.type);
-        const internalConfig = workerConfig;
-        const staggerOffset = internalConfig.offsetMs || 0;
-        // Calculate initial delay with stagger offset
-        let initialDelay = staggerOffset;
-        if (state.lastRun) {
-            const timeSinceLastRun = Date.now() - state.lastRun.getTime();
-            initialDelay = Math.max(staggerOffset, workerConfig.intervalMs - timeSinceLastRun);
-        }
-        state.nextRun = new Date(Date.now() + initialDelay);
-        const runAndReschedule = async () => {
-            if (!this.running)
-                return;
-            // Use concurrency-controlled execution (P0 fix)
-            await this.executeWorkerWithConcurrencyControl(workerConfig);
-            // Reschedule
-            if (this.running) {
-                const timer = setTimeout(runAndReschedule, workerConfig.intervalMs);
-                this.timers.set(workerConfig.type, timer);
-                state.nextRun = new Date(Date.now() + workerConfig.intervalMs);
-            }
-        };
-        // Schedule first run with stagger offset
-        const timer = setTimeout(runAndReschedule, initialDelay);
-        this.timers.set(workerConfig.type, timer);
-        this.log('info', `Scheduled ${workerConfig.type} (interval: ${workerConfig.intervalMs / 1000}s, first run in ${initialDelay / 1000}s)`);
-    }
-    /**
-     * Execute a worker with concurrency control (P0 fix)
-     */
-    async executeWorkerWithConcurrencyControl(workerConfig) {
-        // Dedup: under sustained resource pressure each scheduler tick re-pushes
-        // the same WorkerType. Without dedup, high-priority workers (audit) crowd
-        // out low-priority ones (consolidate) — starvation. Skip the push if the
-        // type is already pending.
-        const pushPending = (type) => {
-            if (!this.pendingWorkers.includes(type))
-                this.pendingWorkers.push(type);
-        };
-        // Check concurrency limit
-        if (this.runningWorkers.size >= this.config.maxConcurrent) {
-            this.log('info', `Worker ${workerConfig.type} deferred: max concurrent (${this.config.maxConcurrent}) reached`);
-            pushPending(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}`);
-            pushPending(workerConfig.type);
-            this.emit('worker:deferred', { type: workerConfig.type, reason: resourceCheck.reason });
-            return null;
-        }
-        return this.executeWorker(workerConfig);
-    }
-    /**
-     * Execute a worker with timeout protection
-     */
-    async executeWorker(workerConfig) {
-        const state = this.workers.get(workerConfig.type);
-        const workerId = `${workerConfig.type}_${Date.now()}`;
-        const startTime = Date.now();
-        // Track the headless executionId assigned by HeadlessWorkerExecutor so we
-        // can cancel it precisely on timeout. The executor generates its own ID
-        // (format: `${type}_${ts}_${random}`) which never matches workerId, so we
-        // capture it from the 'start' event instead.
-        let headlessExecutionId = null;
-        const onHeadlessStart = (data) => {
-            headlessExecutionId = data.executionId ?? null;
-        };
-        if (this.headlessExecutor) {
-            this.headlessExecutor.on('start', onHeadlessStart);
-        }
-        // 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 only this worker's child process on timeout.
-            // cancelAll() was too broad — it would kill concurrent healthy workers.
-            const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
-                if (this.headlessExecutor) {
-                    // Use the exact executionId captured from the 'start' event.
-                    // Fall back to cancelByType only if we didn't capture an ID yet
-                    // (e.g. timeout fired before the executor emitted 'start').
-                    if (headlessExecutionId && this.headlessExecutor.cancel(headlessExecutionId)) {
-                        return;
-                    }
-                    this.headlessExecutor.cancelByType(workerConfig.type);
-                }
-            });
-            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);
-            // Unsubscribe the executionId capture listener regardless of outcome
-            if (this.headlessExecutor) {
-                this.headlessExecutor.off('start', onHeadlessStart);
-            }
-            this.processPendingWorkers();
-        }
-    }
-    /**
-     * Run a function with timeout (P1 fix)
-     * @param fn - The async function to execute
-     * @param timeoutMs - Timeout in milliseconds
-     * @param timeoutMessage - Error message on timeout
-     * @param onTimeout - Optional cleanup callback invoked when timeout fires (#1117: kills orphan processes)
-     */
-    async runWithTimeout(fn, timeoutMs, timeoutMessage, onTimeout) {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                // Kill orphan child processes before rejecting (#1117)
-                if (onTimeout) {
-                    try {
-                        onTimeout();
-                    }
-                    catch {
-                        // Ignore cleanup errors
-                    }
-                }
-                reject(new Error(timeoutMessage));
-            }, timeoutMs);
-            fn()
-                .then((result) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                resolve(result);
-            })
-                .catch((error) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * Run the actual worker logic
-     */
-    async runWorkerLogic(workerConfig) {
-        // Check if this is a headless worker type and headless execution is available
-        if (isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor) {
-            try {
-                this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
-                const result = await this.headlessExecutor.execute(workerConfig.type);
-                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 'ultralearn':
-                return this.runUltralearnWorkerLocal();
-            case 'deepdive':
-                return this.runDeepdiveWorkerLocal();
-            case 'benchmark':
-                return this.runBenchmarkWorkerLocal();
-            // testgaps/predict/document/refactor/preload have no real local-mode
-            // implementation — they only do real work in headless mode (see
-            // HeadlessWorkerExecutor). Without Claude Code CLI available there is
-            // nothing meaningful to run locally, so report that plainly instead of
-            // faking a result with hardcoded empty JSON (monolean).
-            case 'testgaps':
-            case 'predict':
-            case 'document':
-            case 'refactor':
-            case 'preload':
-                return { mode: 'local', note: 'Install Claude Code CLI for AI-powered analysis — no local implementation exists for this worker' };
-            default:
-                return { status: 'unknown worker type', mode: 'local' };
-        }
-    }
-    // Worker implementations
-    async runMapWorker() {
-        // Scan project structure and update metrics
-        const metricsFile = join(this.projectRoot, '.monomind', 'metrics', 'codebase-map.json');
-        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const map = {
-            timestamp: new Date().toISOString(),
-            structure: {
-                hasPackageJson: existsSync(join(this.projectRoot, 'package.json')),
-                hasTsConfig: existsSync(join(this.projectRoot, 'tsconfig.json')),
-                hasClaudeConfig: existsSync(join(this.projectRoot, '.claude')),
-                hasMonomind: existsSync(join(this.projectRoot, '.monomind')),
-            },
-            scannedAt: Date.now(),
-        };
-        // Enrich with monograph graph stats for LLM context injection.
-        // Lazy-import to avoid hard dependency; silently skip on any error.
-        try {
-            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
-            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
-            if (existsSync(dbPath)) {
-                const db = openDb(dbPath);
-                try {
-                    // Node/edge counts
-                    map['graph'] = {
-                        nodes: countNodes(db),
-                        edges: countEdges(db),
-                    };
-                    // Top 3 god nodes (high degree internal files) — same SQL as monograph_god_nodes tool
-                    const excluded = ['File', 'Folder', 'Community', 'Concept'];
-                    const rows = db.prepare(`
-            SELECT n.name, n.file_path, n.start_line,
-                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
-            FROM nodes n
-            LEFT JOIN edges e1 ON e1.source_id = n.id
-            LEFT JOIN edges e2 ON e2.target_id = n.id
-            WHERE n.label NOT IN (${excluded.map(() => '?').join(',')})
-            GROUP BY n.id HAVING degree > 0
-            ORDER BY degree DESC LIMIT 3
-          `).all(...excluded);
-                    if (rows.length > 0) {
-                        map['topFiles'] = rows.map(r => ({
-                            ref: r.file_path
-                                ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
-                                : r.name,
-                            degree: r.degree,
-                        }));
-                    }
-                    // Index staleness via git — same approach as monograph_health tool
-                    try {
-                        const { execSync } = await import('child_process');
-                        const lastHash = db.prepare("SELECT value FROM meta WHERE key = 'last_commit_hash' LIMIT 1").get()?.value;
-                        if (lastHash) {
-                            const countOut = execSync(`git -C ${JSON.stringify(this.projectRoot)} rev-list --count ${lastHash}..HEAD`, { timeout: 5000 }).toString().trim();
-                            const commitsBehind = parseInt(countOut, 10);
-                            if (!isNaN(commitsBehind)) {
-                                map['graphStaleness'] = { commitsBehind };
-                            }
-                        }
-                    }
-                    catch { /* git unavailable — skip staleness */ }
-                }
-                finally {
-                    closeDb(db);
-                }
-            }
-        }
-        catch { /* monograph unavailable — skip graph enrichment */ }
-        const metricsFileTmp1 = metricsFile + '.tmp';
-        writeFileSync(metricsFileTmp1, JSON.stringify(map, null, 2));
-        renameSync(metricsFileTmp1, metricsFile);
-        return map;
-    }
-    /**
-     * Local audit worker (fallback when headless unavailable)
-     */
-    async runAuditWorkerLocal() {
-        // Basic security checks
-        const auditFile = join(this.projectRoot, '.monomind', 'metrics', 'security-audit.json');
-        const metricsDir = join(this.projectRoot, '.monomind', '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: null, // Not checked in local mode — requires AI-powered scan
-            },
-            riskLevel: 'low',
-            recommendations: [],
-            note: 'Install Claude Code CLI for AI-powered security analysis',
-        };
-        // Enrich with monograph high-centrality files and surprising cross-community edges.
-        // God-node files are high-value targets for security review: they are imported by
-        // many consumers, so a vulnerability there has the largest blast radius.
-        // Cross-community edges reveal unexpected coupling that may indicate hidden attack surfaces.
-        try {
-            const { openDb, closeDb } = await import('@monoes/monograph');
-            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
-            if (existsSync(dbPath)) {
-                const db = openDb(dbPath);
-                try {
-                    const godFileRows = db.prepare(`
-            SELECT n.file_path,
-                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
-            FROM nodes n
-            LEFT JOIN edges e1 ON e1.source_id = n.id
-            LEFT JOIN edges e2 ON e2.target_id = n.id
-            WHERE n.label NOT IN ('File','Folder','Community','Concept')
-              AND n.file_path IS NOT NULL
-              AND n.file_path NOT LIKE '%node_modules%'
-              AND n.file_path NOT LIKE '%/dist/%'
-              AND n.file_path NOT LIKE '%.test.%'
-              AND n.file_path NOT LIKE '%.spec.%'
-            GROUP BY n.file_path
-            ORDER BY degree DESC
-            LIMIT 5
-          `).all();
-                    const surpriseRows = db.prepare(`
-            SELECT n1.name as src_name, n2.name as tgt_name, e.relation, e.confidence_score,
-                   n1.file_path as src_file, n2.file_path as tgt_file
-            FROM edges e
-            JOIN nodes n1 ON n1.id = e.source_id
-            JOIN nodes n2 ON n2.id = e.target_id
-            WHERE e.confidence != 'EXTRACTED'
-              AND n1.community_id IS NOT NULL
-              AND n2.community_id IS NOT NULL
-              AND n1.community_id != n2.community_id
-            ORDER BY e.confidence_score ASC
-            LIMIT 5
-          `).all();
-                    if (godFileRows.length > 0) {
-                        audit['priorityScanTargets'] = godFileRows.map(r => ({
-                            file: r.file_path.replace(this.projectRoot + '/', '').replace(this.projectRoot + '\\', ''),
-                            degree: r.degree,
-                            reason: 'high-centrality: vulnerability here affects the most consumers',
-                        }));
-                    }
-                    if (surpriseRows.length > 0) {
-                        audit['unexpectedCoupling'] = surpriseRows.map(r => ({
-                            edge: `${r.src_name} --${r.relation}--> ${r.tgt_name}`,
-                            srcFile: r.src_file ?? '(unknown)',
-                            tgtFile: r.tgt_file ?? '(unknown)',
-                            confidenceScore: r.confidence_score,
-                            reason: 'cross-community edge: may indicate hidden dependency or attack surface',
-                        }));
-                    }
-                }
-                finally {
-                    closeDb(db);
-                }
-            }
-        }
-        catch { /* monograph unavailable — skip graph enrichment */ }
-        const auditFileTmp = auditFile + '.tmp';
-        writeFileSync(auditFileTmp, JSON.stringify(audit, null, 2));
-        renameSync(auditFileTmp, auditFile);
-        return audit;
-    }
-    /**
-     * Local optimize worker (fallback when headless unavailable)
-     */
-    async runOptimizeWorkerLocal() {
-        // Update performance metrics
-        const optimizeFile = join(this.projectRoot, '.monomind', 'metrics', 'performance.json');
-        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const perf = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            memoryUsage: process.memoryUsage(),
-            uptime: process.uptime(),
-            optimizations: {
-                cacheHitRate: null, // Not measured in local mode — requires AI-powered analysis
-                avgResponseTime: null, // Not measured in local mode — requires AI-powered analysis
-            },
-            note: 'Install Claude Code CLI for AI-powered optimization suggestions',
-        };
-        const optimizeFileTmp = optimizeFile + '.tmp';
-        writeFileSync(optimizeFileTmp, JSON.stringify(perf, null, 2));
-        renameSync(optimizeFileTmp, optimizeFile);
-        return perf;
-    }
-    async runConsolidateWorker() {
-        // RAPTOR-style memory consolidation: cluster episodic entries by namespace,
-        // generate a summary entry as 'contextual' type referencing source cluster.
-        // Source: https://arxiv.org/abs/2401.18059 (RAPTOR — ICLR 2024)
-        const consolidateFile = join(this.projectRoot, '.monomind', 'metrics', 'consolidation.json');
-        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        let patternsConsolidated = 0;
-        let clustersCreated = 0;
-        try {
-            // Lazy-import memory bridge to avoid hard dependency in worker
-            const { bridgeSearchEntries, bridgeStoreEntry } = await import('../memory/memory-bridge.js');
-            // Retrieve recent episodic entries (short-term tier) for RAPTOR clustering
-            const episodic = await bridgeSearchEntries({
-                query: 'task outcome agent pattern',
-                namespace: 'patterns',
-                limit: 50,
-                threshold: 0.0,
-            });
-            if (episodic?.results && episodic.results.length >= 3) {
-                // Group into clusters of ~5 by simple sequential chunking
-                const CLUSTER_SIZE = 5;
-                for (let i = 0; i < episodic.results.length; i += CLUSTER_SIZE) {
-                    const cluster = episodic.results.slice(i, i + CLUSTER_SIZE);
-                    if (cluster.length < 2)
-                        continue;
-                    // Build cluster summary (lightweight abstraction without LLM)
-                    const keys = cluster.map(r => r.key).join(', ');
-                    const summary = `RAPTOR cluster [${Math.floor(i / CLUSTER_SIZE)}]: ` +
-                        `${cluster.length} patterns consolidated. Topics: ${keys.slice(0, 120)}`;
-                    await bridgeStoreEntry({
-                        key: `raptor_cluster:${Date.now()}_${i}`,
-                        value: summary,
-                        namespace: 'contextual',
-                        tags: ['raptor', 'cluster_summary'],
-                    });
-                    patternsConsolidated += cluster.length;
-                    clustersCreated++;
-                }
-            }
-        }
-        catch { /* non-critical — bridge may be unavailable */ }
-        const result = {
-            timestamp: new Date().toISOString(),
-            patternsConsolidated,
-            clustersCreated,
-            memoryCleaned: 0,
-            duplicatesRemoved: 0,
-            mode: 'raptor',
-        };
-        const consolidateFileTmp = consolidateFile + '.tmp';
-        writeFileSync(consolidateFileTmp, JSON.stringify(result, null, 2));
-        renameSync(consolidateFileTmp, consolidateFile);
-        return result;
-    }
-    /**
-     * Local ultralearn worker (fallback when headless unavailable)
-     */
-    async runUltralearnWorkerLocal() {
-        const result = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            patternsLearned: 0,
-            insightsGained: [],
-        };
-        // Enrich with monograph community clusters and bridge-node patterns for LLM context injection.
-        // Bridge nodes (symbols that cross community boundaries) are architecturally significant —
-        // they represent coupling points an LLM should be aware of when reasoning about change impact.
-        try {
-            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
-            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
-            if (existsSync(dbPath)) {
-                const db = openDb(dbPath);
-                try {
-                    const nodeCount = countNodes(db);
-                    const edgeCount = countEdges(db);
-                    const communityRows = db.prepare(`
-            SELECT community_id, COUNT(*) AS member_count
-            FROM nodes
-            WHERE community_id IS NOT NULL
-              AND label NOT IN ('File','Folder','Community','Concept')
-            GROUP BY community_id
-            ORDER BY member_count DESC
-            LIMIT 5
-          `).all();
-                    const bridgeRows = db.prepare(`
-            SELECT n.name, n.label, n.file_path, n.start_line,
-                   COUNT(DISTINCT e.id) AS cross_edges
-            FROM nodes n
-            JOIN edges e ON (e.source_id = n.id OR e.target_id = n.id)
-            JOIN nodes n2 ON (
-              CASE WHEN e.source_id = n.id THEN e.target_id ELSE e.source_id END = n2.id
-            )
-            WHERE n.community_id IS NOT NULL
-              AND n2.community_id IS NOT NULL
-              AND n.community_id != n2.community_id
-              AND n.label NOT IN ('File','Folder','Community','Concept')
-              AND (n.file_path IS NULL OR (
-                n.file_path NOT LIKE '%node_modules%'
-                AND n.file_path NOT LIKE '%/dist/%'
-                AND n.file_path NOT LIKE '%.test.%'
-                AND n.file_path NOT LIKE '%.spec.%'
-              ))
-            GROUP BY n.id
-            ORDER BY cross_edges DESC
-            LIMIT 5
-          `).all();
-                    const insights = result['insightsGained'];
-                    if (communityRows.length > 0) {
-                        insights.push({
-                            category: 'community_clusters',
-                            description: `Top ${communityRows.length} community clusters by size`,
-                            items: communityRows.map(r => ({
-                                communityId: r.community_id,
-                                memberCount: r.member_count,
-                            })),
-                        });
-                    }
-                    if (bridgeRows.length > 0) {
-                        insights.push({
-                            category: 'bridge_nodes',
-                            description: `Top ${bridgeRows.length} bridge nodes crossing community boundaries (high coupling risk)`,
-                            items: bridgeRows.map(r => {
-                                const loc = r.file_path
-                                    ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
-                                    : '(unknown)';
-                                return {
-                                    name: r.name,
-                                    label: r.label,
-                                    location: loc,
-                                    crossCommunityEdges: r.cross_edges,
-                                };
-                            }),
-                        });
-                        result['patternsLearned'] = bridgeRows.length + communityRows.length;
-                    }
-                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
-                }
-                finally {
-                    closeDb(db);
-                }
-            }
-            else {
-                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep learning';
-            }
-        }
-        catch { /* monograph unavailable — return minimal result */ }
-        return result;
-    }
-    /**
-     * Local deepdive worker (fallback when headless unavailable)
-     */
-    async runDeepdiveWorkerLocal() {
-        const deepdiveFile = join(this.projectRoot, '.monomind', 'metrics', 'deepdive.json');
-        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
-        if (!existsSync(metricsDir)) {
-            mkdirSync(metricsDir, { recursive: true });
-        }
-        const result = {
-            timestamp: new Date().toISOString(),
-            mode: 'local',
-            analysisDepth: 'graph',
-            findings: [],
-        };
-        // Enrich with monograph god nodes and high-degree file analysis for LLM context injection.
-        // Lazy-import to avoid hard dependency; silently skip on any error.
-        try {
-            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
-            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
-            if (existsSync(dbPath)) {
-                const db = openDb(dbPath);
-                try {
-                    const nodeCount = countNodes(db);
-                    const edgeCount = countEdges(db);
-                    const godNodeRows = db.prepare(`
-            SELECT n.name, n.file_path, n.label,
-                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
-            FROM nodes n
-            LEFT JOIN edges e1 ON e1.source_id = n.id
-            LEFT JOIN edges e2 ON e2.target_id = n.id
-            WHERE n.label NOT IN ('File','Folder','Community','Concept')
-              AND (n.file_path IS NULL OR (
-                n.file_path NOT LIKE '%node_modules%'
-                AND n.file_path NOT LIKE '%/dist/%'
-                AND n.file_path NOT LIKE '%.test.%'
-                AND n.file_path NOT LIKE '%.spec.%'
-              ))
-            GROUP BY n.id
-            ORDER BY degree DESC
-            LIMIT 5
-          `).all();
-                    const godNodes = godNodeRows.map(r => ({
-                        name: r.name,
-                        label: r.label,
-                        file: r.file_path ?? '(unknown)',
-                        degree: r.degree,
-                    }));
-                    const fileRows = db.prepare(`
-            SELECT n.file_path,
-                   COUNT(DISTINCT e2.id) AS in_deg,
-                   COUNT(DISTINCT e1.id) AS out_deg
-            FROM nodes n
-            LEFT JOIN edges e1 ON e1.source_id = n.id
-            LEFT JOIN edges e2 ON e2.target_id = n.id
-            WHERE n.label = 'File'
-              AND n.file_path NOT LIKE '%node_modules%'
-              AND n.file_path NOT LIKE '%/dist/%'
-              AND n.file_path NOT LIKE '%.test.%'
-              AND n.file_path NOT LIKE '%.spec.%'
-            GROUP BY n.id
-            ORDER BY (in_deg + out_deg) DESC
-            LIMIT 5
-          `).all();
-                    const highDegFiles = fileRows.map(r => ({
-                        file: r.file_path
-                            .replace(this.projectRoot + '/', '')
-                            .replace(this.projectRoot + '\\', ''),
-                        inDegree: r.in_deg,
-                        outDegree: r.out_deg,
-                        totalDegree: r.in_deg + r.out_deg,
-                    }));
-                    const findings = [];
-                    if (godNodes.length > 0) {
-                        findings.push({
-                            category: 'god_nodes',
-                            description: `Top ${godNodes.length} high-centrality symbols (most imported/referenced)`,
-                            items: godNodes,
-                        });
-                    }
-                    if (highDegFiles.length > 0) {
-                        findings.push({
-                            category: 'high_degree_files',
-                            description: `Top ${highDegFiles.length} files by total edge degree (import + export connections)`,
-                            items: highDegFiles,
-                        });
-                    }
-                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
-                    result['findings'] = findings;
-                    result['analysisDepth'] = 'graph';
-                }
-                finally {
-                    closeDb(db);
-                }
-            }
-            else {
-                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep analysis';
-            }
-        }
-        catch { /* monograph unavailable — return minimal result */ }
-        const deepdiveFileTmp = deepdiveFile + '.tmp';
-        writeFileSync(deepdiveFileTmp, JSON.stringify(result, null, 2));
-        renameSync(deepdiveFileTmp, deepdiveFile);
-        return result;
-    }
-    /**
-     * Local benchmark worker
-     */
-    async runBenchmarkWorkerLocal() {
-        const benchmarkFile = join(this.projectRoot, '.monomind', 'metrics', 'benchmark.json');
-        const metricsDir = join(this.projectRoot, '.monomind', '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(),
-            },
-        };
-        const benchmarkFileTmp = benchmarkFile + '.tmp';
-        writeFileSync(benchmarkFileTmp, JSON.stringify(result, null, 2));
-        renameSync(benchmarkFileTmp, benchmarkFile);
-        return result;
-    }
-    /**
-     * 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}`);
-        }
-        const result = await this.executeWorkerWithConcurrencyControl(workerConfig);
-        if (result !== null)
-            return result;
-        // Concurrency limit reached — execute directly for explicit manual trigger.
-        // Remove from pendingWorkers to avoid double execution when finally fires.
-        const pendingIdx = this.pendingWorkers.indexOf(workerConfig.type);
-        if (pendingIdx !== -1)
-            this.pendingWorkers.splice(pendingIdx, 1);
-        return this.executeWorker(workerConfig);
-    }
-    /**
-     * Enable/disable a worker
-     */
-    setWorkerEnabled(type, enabled) {
-        const workerConfig = this.config.workers.find(w => w.type === type);
-        if (workerConfig) {
-            workerConfig.enabled = enabled;
-            if (enabled && this.running) {
-                this.scheduleWorker(workerConfig);
-            }
-            else if (!enabled) {
-                const timer = this.timers.get(type);
-                if (timer) {
-                    clearTimeout(timer);
-                    this.timers.delete(type);
-                }
-            }
-            this.saveState();
-        }
-    }
-    /**
-     * Save daemon state to file
-     */
-    saveState() {
-        const state = {
-            running: this.running,
-            startedAt: this.startedAt?.toISOString(),
-            workers: Object.fromEntries(Array.from(this.workers.entries()).map(([type, state]) => [
-                type,
-                {
-                    ...state,
-                    lastRun: state.lastRun?.toISOString(),
-                    nextRun: state.nextRun?.toISOString(),
-                }
-            ])),
-            config: {
-                ...this.config,
-                workers: this.config.workers.map(w => ({ ...w })),
-            },
-            savedAt: new Date().toISOString(),
-        };
-        try {
-            const tmp = this.config.stateFile + '.tmp';
-            writeFileSync(tmp, JSON.stringify(state, null, 2));
-            renameSync(tmp, this.config.stateFile);
-        }
-        catch (error) {
-            this.log('error', `Failed to save state: ${error}`);
-        }
-    }
-    /**
-     * Log message
-     */
-    log(level, message) {
-        const timestamp = new Date().toISOString();
-        const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-        this.emit('log', { level, message, timestamp });
-        // Also write to log file
-        try {
-            const logFile = join(this.config.logDir, 'daemon.log');
-            appendFileSync(logFile, logMessage + '\n');
-            // Opportunistic rotation: keep the log under 10 MB. When exceeded,
-            // discard the oldest half so recent entries are always retained.
-            const MAX_LOG_BYTES = 10 * 1024 * 1024;
-            if (statSync(logFile).size > MAX_LOG_BYTES) {
-                const content = readFileSync(logFile, 'utf-8');
-                const lines = content.split('\n').filter(Boolean);
-                const trimmed = lines.slice(Math.floor(lines.length / 2)).join('\n') + '\n';
-                const tmp = `${logFile}.${process.pid}.${Date.now()}.tmp`;
-                writeFileSync(tmp, trimmed);
-                renameSync(tmp, logFile);
-            }
-        }
-        catch {
-            // Ignore log write errors
-        }
-    }
-}
-// Singleton instance for global access
-let daemonInstance = null;
-/**
- * Get or create daemon instance
- */
-export function getDaemon(projectRoot, config) {
-    if (!daemonInstance && projectRoot) {
-        daemonInstance = new WorkerDaemon(projectRoot, config);
-    }
-    if (!daemonInstance) {
-        throw new Error('Daemon not initialized. Provide projectRoot on first call.');
-    }
-    return daemonInstance;
-}
-/**
- * Start daemon (for use in session-start hook)
- */
-export async function startDaemon(projectRoot, config) {
-    // A2: the daemon is a long-lived host — keep the SONA write-path enabled so
-    // trajectories accumulate across worker runs and reach the consolidation
-    // threshold (see startMCPServer for the one-shot-CLI rationale).
-    process.env.MONOMIND_PERSISTENT_HOST = '1';
-    const daemon = getDaemon(projectRoot, config);
-    await daemon.start();
-    return daemon;
-}
-/**
- * Stop daemon
- */
-export async function stopDaemon() {
-    if (daemonInstance) {
-        await daemonInstance.stop();
-    }
-}
-export default WorkerDaemon;
-//# sourceMappingURL=worker-daemon.js.map