grepmax 0.17.24 → 0.18.0

package/dist/lib/daemon/daemon.js

@@ -41,13 +41,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -56,12 +49,9 @@ exports.Daemon = void 0;
 const fs = __importStar(require("node:fs"));
 const net = __importStar(require("node:net"));
 const path = __importStar(require("node:path"));
-const watcher = __importStar(require("@parcel/watcher"));
 const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
 const config_1 = require("../../config");
-const batch_processor_1 = require("../index/batch-processor");
 const syncer_1 = require("../index/syncer");
-const watcher_1 = require("../index/watcher");
 const search_handler_1 = require("./search-handler");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
@@ -70,14 +60,14 @@ const project_registry_1 = require("../utils/project-registry");
 const watcher_store_1 = require("../utils/watcher-store");
 const server_1 = require("../llm/server");
 const ipc_handler_1 = require("./ipc-handler");
+const process_manager_1 = require("./process-manager");
+const mlx_server_manager_1 = require("./mlx-server-manager");
+const watcher_manager_1 = require("./watcher-manager");
 const logger_1 = require("../utils/logger");
-const daemon_client_1 = require("../utils/daemon-client");
 const index_config_1 = require("../index/index-config");
 const log_rotate_1 = require("../utils/log-rotate");
 const pool_1 = require("../workers/pool");
 const daemon_launcher_1 = require("../utils/daemon-launcher");
-const node_child_process_1 = require("node:child_process");
-const http = __importStar(require("node:http"));
 // 30 min was too aggressive — every shutdown is a chance for races, FSEvents
 // drops, and orphan MLX cleanup. 4 hours keeps the daemon resident through a
 // normal workday while still freeing resources overnight. Override with
@@ -110,9 +100,6 @@ const envNum = (name, fallback) => {
 };
 const MAX_LIFETIME_MS = envNum("GMAX_DAEMON_MAX_LIFETIME_MS", 24 * 60 * 60 * 1000);
 const RSS_WATERMARK_MB = envNum("GMAX_DAEMON_RSS_WATERMARK_MB", 2560);
-// Watcher health windows used for FSEvents auto-recovery.
-const FSEVENTS_RECOVERY_INTERVAL_MS = 60 * 60 * 1000; // try recovery hourly
-const FSEVENTS_HEALTH_WINDOW_MS = 5 * 60 * 1000; // 5 min of quiet = "healthy"
 class Daemon {
     constructor() {
         this.processors = new Map();
@@ -127,19 +114,23 @@ class Daemon {
         this.heartbeatInterval = null;
         this.idleInterval = null;
         this.heartbeatTick = 0;
-        this.mlxRecoveryInFlight = false;
         this.shuttingDown = false;
         this.recycling = false;
-        // PIDs flagged as orphan workers on the previous sweep. A worker must look
-        // orphaned twice in a row before we kill it, so a worker the pool forked
-        // between our process snapshot and its array update is never killed by a race.
-        this.suspectedOrphanWorkers = new Set();
-        this.pendingOps = new Set();
-        this.watcherFailCount = new Map();
-        this.pollIntervals = new Map();
-        this.pollRecoveryTimers = new Map();
-        this.lastOverflowMs = new Map();
-        this.lastCatchupEndMs = new Map();
+        this.processManager = new process_manager_1.ProcessManager({
+            getShuttingDown: () => this.shuttingDown,
+        });
+        this.mlxServerManager = new mlx_server_manager_1.MlxServerManager({
+            getShuttingDown: () => this.shuttingDown,
+        });
+        this.watcherManager = new watcher_manager_1.WatcherManager({
+            processors: this.processors,
+            subscriptions: this.subscriptions,
+            getVectorDb: () => this.vectorDb,
+            getMetaCache: () => this.metaCache,
+            getShuttingDown: () => this.shuttingDown,
+            touchActivity: () => { this.lastActivity = Date.now(); },
+            evictSearcher: (root) => { this.searchers.delete(root); },
+        });
         this.projectLocks = new Map();
         // Full-index progress per root while initialSync runs (--reset / initial
         // index). Presence = a full index is in flight; value drives the partial-
@@ -147,13 +138,12 @@ class Daemon {
         this.indexProgress = new Map();
         this.shutdownAbortControllers = new Set();
         this.llmServer = null;
-        this.mlxChild = null;
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             process.title = "gmax-daemon";
             // 0. Singleton enforcement: find and kill ALL stale daemon/worker processes
-            yield this.killStaleProcesses();
+            yield this.processManager.killStaleProcesses();
             // 1. Acquire exclusive lock — kernel-enforced, atomic, auto-released on death
             fs.mkdirSync(path.dirname(config_1.PATHS.daemonLockFile), { recursive: true });
             fs.writeFileSync(config_1.PATHS.daemonLockFile, "", { flag: "a" }); // ensure file exists
@@ -270,7 +260,7 @@ class Daemon {
             const globalConfig = (0, index_config_1.readGlobalConfig)();
             const isAppleSilicon = process.arch === "arm64" && process.platform === "darwin";
             if (isAppleSilicon && globalConfig.embedMode === "gpu") {
-                yield this.ensureMlxServer(globalConfig.mlxModel);
+                yield this.mlxServerManager.ensureMlxServer(globalConfig.mlxModel);
             }
             // 7. Register daemon (only after resources are open)
             (0, watcher_store_1.registerDaemon)(process.pid);
@@ -323,8 +313,8 @@ class Daemon {
                 // after a frozen MLX process kept the port bound (v0.17.0 bug #1).
                 this.heartbeatTick++;
                 if (this.heartbeatTick % 5 === 0) {
-                    void this.checkMlxHealth();
-                    this.sweepOrphanWorkers();
+                    void this.mlxServerManager.checkMlxHealth();
+                    this.processManager.sweepOrphanWorkers();
                     this.maybeRecycle();
                 }
             }, HEARTBEAT_INTERVAL_MS);
@@ -390,355 +380,7 @@ class Daemon {
     }
     watchProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.processors.has(root) || this.pendingOps.has(root))
-                return;
-            if (!this.vectorDb || !this.metaCache)
-                return;
-            this.pendingOps.add(root);
-            const processor = new batch_processor_1.ProjectBatchProcessor({
-                projectRoot: root,
-                vectorDb: this.vectorDb,
-                metaCache: this.metaCache,
-                onReindex: (files, ms) => __awaiter(this, void 0, void 0, function* () {
-                    console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
-                    // Update project registry so gmax status shows fresh data
-                    const proj = (0, project_registry_1.getProject)(root);
-                    if (proj) {
-                        let chunkCount = proj.chunkCount;
-                        try {
-                            chunkCount = yield this.vectorDb.countRowsForPath(root);
-                        }
-                        catch (err) {
-                            console.warn(`[daemon:${path.basename(root)}] Failed to query chunk count: ${err}`);
-                        }
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount }));
-                    }
-                    // Back to watching after batch completes
-                    (0, watcher_store_1.registerWatcher)({
-                        pid: process.pid,
-                        projectRoot: root,
-                        startTime: Date.now(),
-                        status: "watching",
-                        lastHeartbeat: Date.now(),
-                        lastReindex: Date.now(),
-                    });
-                }),
-                onActivity: () => {
-                    this.lastActivity = Date.now();
-                    // Mark as syncing while processing
-                    (0, watcher_store_1.registerWatcher)({
-                        pid: process.pid,
-                        projectRoot: root,
-                        startTime: Date.now(),
-                        status: "syncing",
-                        lastHeartbeat: Date.now(),
-                    });
-                },
-            });
-            this.processors.set(root, processor);
-            // Subscribe with @parcel/watcher — native backend, no polling.
-            // If the kernel refuses (e.g. FSEvents slots stuck after a prior kill -9),
-            // fall straight through to poll mode. The retry/backoff path inside
-            // recoverWatcher is for transient overflows, not hard kernel-level
-            // subscribe failures, so we skip it on startup by priming failCount past
-            // MAX before invoking it.
-            try {
-                yield this.subscribeWatcher(root, processor);
-            }
-            catch (err) {
-                const name = path.basename(root);
-                console.error(`[daemon:${name}] Subscribe failed at startup (${err instanceof Error ? err.message : err}) — switching to poll mode`);
-                this.watcherFailCount.set(root, 1000); // > MAX_WATCHER_RETRIES
-                this.lastOverflowMs.set(root, Date.now());
-                this.recoverWatcher(root, processor);
-            }
-            (0, watcher_store_1.registerWatcher)({
-                pid: process.pid,
-                projectRoot: root,
-                startTime: Date.now(),
-                status: "watching",
-                lastHeartbeat: Date.now(),
-            });
-            // Catchup scan — find files changed while daemon was offline
-            this.catchupScan(root, processor).catch((err) => {
-                console.error(`[daemon:${path.basename(root)}] Catchup scan failed:`, err);
-            });
-            this.pendingOps.delete(root);
-            console.log(`[daemon] Watching ${root}`);
-        });
-    }
-    subscribeWatcher(root, processor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const name = path.basename(root);
-            // Unsubscribe existing watcher if any (e.g. during recovery)
-            const existingSub = this.subscriptions.get(root);
-            if (existingSub) {
-                try {
-                    yield existingSub.unsubscribe();
-                }
-                catch (_a) { }
-                this.subscriptions.delete(root);
-            }
-            const sub = yield watcher.subscribe(root, (err, events) => {
-                var _a;
-                if (err) {
-                    console.error(`[daemon:${name}] Watcher error:`, err);
-                    this.recoverWatcher(root, processor);
-                    return;
-                }
-                // Only reset fail counter after sustained health (5min since last overflow)
-                const lastOverflow = (_a = this.lastOverflowMs.get(root)) !== null && _a !== void 0 ? _a : 0;
-                if (Date.now() - lastOverflow > 5 * 60 * 1000) {
-                    this.watcherFailCount.delete(root);
-                }
-                for (const event of events) {
-                    processor.handleFileEvent(event.type === "delete" ? "unlink" : "change", event.path);
-                }
-                this.lastActivity = Date.now();
-            }, { ignore: watcher_1.WATCHER_IGNORE_GLOBS });
-            this.subscriptions.set(root, sub);
-        });
-    }
-    recoverWatcher(root, processor) {
-        var _a;
-        const name = path.basename(root);
-        if (this.shuttingDown)
-            return;
-        // Debounce: avoid multiple overlapping recovery attempts
-        const recoveryKey = `recover:${root}`;
-        if (this.pendingOps.has(recoveryKey))
-            return;
-        this.pendingOps.add(recoveryKey);
-        const fails = ((_a = this.watcherFailCount.get(root)) !== null && _a !== void 0 ? _a : 0) + 1;
-        this.watcherFailCount.set(root, fails);
-        this.lastOverflowMs.set(root, Date.now());
-        const MAX_WATCHER_RETRIES = 3;
-        const POLL_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
-        if (fails > MAX_WATCHER_RETRIES) {
-            // FSEvents can't handle this project — degrade to periodic catchup scans
-            // Always tear down the broken sub, even if poll mode is already active —
-            // this can happen if a recovery attempt resubscribed successfully then
-            // re-overflowed during the 5-min health window.
-            const sub = this.subscriptions.get(root);
-            if (sub) {
-                sub.unsubscribe().catch(() => { });
-                this.subscriptions.delete(root);
-            }
-            if (!this.pollIntervals.has(root)) {
-                console.error(`[daemon:${name}] FSEvents unreliable after ${fails} failures — switching to poll mode (${POLL_INTERVAL_MS / 60000}min interval)`);
-                // Run an immediate catchup, then schedule periodic ones
-                this.catchupScan(root, processor).catch((err) => {
-                    console.error(`[daemon:${name}] Poll catchup failed:`, err);
-                });
-                const interval = setInterval(() => {
-                    if (this.shuttingDown)
-                        return;
-                    this.lastActivity = Date.now();
-                    this.catchupScan(root, processor).catch((err) => {
-                        console.error(`[daemon:${name}] Poll catchup failed:`, err);
-                    });
-                }, POLL_INTERVAL_MS);
-                this.pollIntervals.set(root, interval);
-                // Schedule periodic attempts to climb back to native FSEvents — after
-                // a transient burst (large git checkout, npm install) the kernel
-                // buffer often calms down within an hour.
-                this.schedulePollModeRecovery(root, processor);
-                (0, watcher_store_1.registerWatcher)({
-                    pid: process.pid,
-                    projectRoot: root,
-                    startTime: Date.now(),
-                    status: "watching",
-                    lastHeartbeat: Date.now(),
-                });
-            }
-            this.pendingOps.delete(recoveryKey);
-            return;
-        }
-        // Backoff: wait before re-subscribing (3s, 6s, 12s)
-        const delayMs = 3000 * Math.pow(2, fails - 1);
-        console.error(`[daemon:${name}] Recovering watcher (attempt ${fails}/${MAX_WATCHER_RETRIES}, backoff ${delayMs}ms)...`);
-        setTimeout(() => {
-            if (this.shuttingDown) {
-                this.pendingOps.delete(recoveryKey);
-                return;
-            }
-            (() => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                try {
-                    yield this.subscribeWatcher(root, processor);
-                    const lastCatchup = (_a = this.lastCatchupEndMs.get(root)) !== null && _a !== void 0 ? _a : 0;
-                    const CATCHUP_COOLDOWN_MS = 60000;
-                    if (Date.now() - lastCatchup < CATCHUP_COOLDOWN_MS) {
-                        console.log(`[daemon:${name}] Skipping catchup scan (last completed ${Math.round((Date.now() - lastCatchup) / 1000)}s ago)`);
-                    }
-                    else {
-                        yield this.catchupScan(root, processor);
-                    }
-                    console.log(`[daemon:${name}] Watcher recovered`);
-                }
-                catch (err) {
-                    console.error(`[daemon:${name}] Watcher recovery failed:`, err);
-                }
-                finally {
-                    this.pendingOps.delete(recoveryKey);
-                }
-            }))();
-        }, delayMs);
-    }
-    /**
-     * Once a project has fallen back to poll mode, periodically try to upgrade
-     * back to native FSEvents. The buffer overflows that triggered the fallback
-     * are usually transient (big git checkout, npm install, build output) — no
-     * point staying in 5-min poll mode forever.
-     */
-    schedulePollModeRecovery(root, processor) {
-        if (this.pollRecoveryTimers.has(root))
-            return;
-        const name = path.basename(root);
-        const timer = setInterval(() => {
-            if (this.shuttingDown)
-                return;
-            // Skip if a watcher recovery is already in flight or we're not in poll mode anymore.
-            if (!this.pollIntervals.has(root)) {
-                const t = this.pollRecoveryTimers.get(root);
-                if (t)
-                    clearInterval(t);
-                this.pollRecoveryTimers.delete(root);
-                return;
-            }
-            if (this.pendingOps.has(`recover:${root}`))
-                return;
-            void (() => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                console.log(`[daemon:${name}] Attempting to leave poll mode and reattach FSEvents...`);
-                try {
-                    // Reset failure counter so subscribeWatcher's error path treats this
-                    // as a fresh start. If it fails again, we'll fall right back into
-                    // poll mode via the same recoverWatcher path.
-                    this.watcherFailCount.delete(root);
-                    yield this.subscribeWatcher(root, processor);
-                    // Wait one health window — if the new subscription survives without
-                    // another overflow, we consider it recovered and tear down poll mode.
-                    yield new Promise((r) => setTimeout(r, FSEVENTS_HEALTH_WINDOW_MS));
-                    if (this.shuttingDown)
-                        return;
-                    const lastOverflow = (_a = this.lastOverflowMs.get(root)) !== null && _a !== void 0 ? _a : 0;
-                    if (Date.now() - lastOverflow < FSEVENTS_HEALTH_WINDOW_MS) {
-                        console.log(`[daemon:${name}] FSEvents recovery aborted — fresh overflow within health window, staying in poll mode`);
-                        return; // recoverWatcher will have re-armed poll mode if needed
-                    }
-                    // Healthy — drop poll mode.
-                    const pollInterval = this.pollIntervals.get(root);
-                    if (pollInterval) {
-                        clearInterval(pollInterval);
-                        this.pollIntervals.delete(root);
-                    }
-                    const recoveryTimer = this.pollRecoveryTimers.get(root);
-                    if (recoveryTimer) {
-                        clearInterval(recoveryTimer);
-                        this.pollRecoveryTimers.delete(root);
-                    }
-                    console.log(`[daemon:${name}] FSEvents recovered — poll mode disabled`);
-                }
-                catch (err) {
-                    console.error(`[daemon:${name}] Poll-mode recovery attempt failed:`, err);
-                }
-            }))();
-        }, FSEVENTS_RECOVERY_INTERVAL_MS);
-        timer.unref();
-        this.pollRecoveryTimers.set(root, timer);
-    }
-    catchupScan(root, processor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            const { walk } = yield Promise.resolve().then(() => __importStar(require("../index/walker")));
-            const { INDEXABLE_EXTENSIONS, MAX_FILE_SIZE_BYTES } = yield Promise.resolve().then(() => __importStar(require("../../config")));
-            const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
-            const rootPrefix = root.endsWith("/") ? root : `${root}/`;
-            const cachedPaths = yield this.metaCache.getKeysWithPrefix(rootPrefix);
-            const seenPaths = new Set();
-            let queued = 0;
-            let skipped = 0;
-            let debugSamples = 0;
-            try {
-                for (var _d = true, _e = __asyncValues(walk(root, {
-                    additionalPatterns: ["**/.git/**", "**/.gmax/**"],
-                })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const relPath = _c;
-                    const absPath = path.join(root, relPath);
-                    const ext = path.extname(absPath).toLowerCase();
-                    const bn = path.basename(absPath).toLowerCase();
-                    if (!INDEXABLE_EXTENSIONS.has(ext) && !INDEXABLE_EXTENSIONS.has(bn))
-                        continue;
-                    seenPaths.add(absPath);
-                    try {
-                        const stats = yield fs.promises.stat(absPath);
-                        // Skip files that are too large or empty — they'll never be indexed
-                        if (stats.size === 0 || stats.size > MAX_FILE_SIZE_BYTES)
-                            continue;
-                        const cached = this.metaCache.get(absPath);
-                        if (!isFileCached(cached, stats)) {
-                            // Fast path: if only mtime changed but size is identical and we have a hash,
-                            // just verify the hash in-process instead of sending to a worker.
-                            if (cached && cached.hash && cached.size === stats.size) {
-                                const { computeBufferHash } = yield Promise.resolve().then(() => __importStar(require("../utils/file-utils")));
-                                const buf = yield fs.promises.readFile(absPath);
-                                const hash = computeBufferHash(buf);
-                                if (hash === cached.hash) {
-                                    // Content unchanged — update mtime in cache and skip worker
-                                    this.metaCache.put(absPath, Object.assign(Object.assign({}, cached), { mtimeMs: stats.mtimeMs }));
-                                    skipped++;
-                                    continue;
-                                }
-                            }
-                            // Debug: log first few misses to diagnose re-queue loops
-                            if (debugSamples < 5) {
-                                (0, logger_1.debug)("catchup", `miss ${relPath}: cached=${cached ? `mtime=${Math.trunc(cached.mtimeMs)} size=${cached.size}` : "null"} stat=mtime=${Math.trunc(stats.mtimeMs)} size=${stats.size}`);
-                                debugSamples++;
-                            }
-                            processor.handleFileEvent("change", absPath);
-                            queued++;
-                            // Throttle: pause periodically during large catchup scans to let the
-                            // batch processor drain and compaction run between bursts.
-                            if (queued % 500 === 0) {
-                                (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
-                                yield new Promise(r => setTimeout(r, 5000));
-                            }
-                        }
-                        else {
-                            skipped++;
-                        }
-                    }
-                    catch (_g) { }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            (0, logger_1.debug)("catchup", `${path.basename(root)}: ${queued} queued, ${skipped} skipped (cached ok), ${seenPaths.size} total`);
-            // Purge files deleted while daemon was offline
-            let purged = 0;
-            for (const cachedPath of cachedPaths) {
-                if (!seenPaths.has(cachedPath)) {
-                    processor.handleFileEvent("unlink", cachedPath);
-                    purged++;
-                }
-            }
-            if (queued > 0 || purged > 0) {
-                const parts = [];
-                if (queued > 0)
-                    parts.push(`${queued} changed`);
-                if (purged > 0)
-                    parts.push(`${purged} deleted`);
-                console.log(`[daemon:${path.basename(root)}] Catchup: ${parts.join(", ")} file(s) while offline`);
-            }
-            this.lastCatchupEndMs.set(root, Date.now());
+            return this.watcherManager.watchProject(root);
         });
     }
     indexPendingProject(root) {
@@ -786,21 +428,7 @@ class Daemon {
     }
     unwatchProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
-            const processor = this.processors.get(root);
-            if (!processor)
-                return;
-            yield processor.close();
-            const sub = this.subscriptions.get(root);
-            if (sub) {
-                yield sub.unsubscribe();
-                this.subscriptions.delete(root);
-            }
-            this.processors.delete(root);
-            this.searchers.delete(root);
-            this.lastOverflowMs.delete(root);
-            this.lastCatchupEndMs.delete(root);
-            (0, watcher_store_1.unregisterWatcherByRoot)(root);
-            console.log(`[daemon] Unwatched ${root}`);
+            return this.watcherManager.unwatchProject(root);
         });
     }
     /**
@@ -1167,135 +795,6 @@ class Daemon {
             }
         });
     }
-    // --- MLX embed server management ---
-    isMlxServerUp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
-            return new Promise((resolve) => {
-                const req = http.get({ hostname: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => { res.resume(); resolve(res.statusCode === 200); });
-                req.on("error", () => resolve(false));
-                req.on("timeout", () => { req.destroy(); resolve(false); });
-            });
-        });
-    }
-    getPortPid(port) {
-        try {
-            const out = (0, node_child_process_1.execSync)(`lsof -ti :${port}`, { timeout: 5000 }).toString().trim();
-            const pid = parseInt(out.split("\n")[0], 10);
-            return Number.isFinite(pid) ? pid : null;
-        }
-        catch (_a) {
-            return null;
-        }
-    }
-    checkMlxHealth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.shuttingDown || this.mlxRecoveryInFlight)
-                return;
-            if (yield this.isMlxServerUp())
-                return;
-            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
-            const stalePid = this.getPortPid(port);
-            if (!stalePid)
-                return; // No process — let the next user-facing path spawn it.
-            this.mlxRecoveryInFlight = true;
-            try {
-                console.log(`[daemon] MLX zombie detected on port ${port} (PID ${stalePid}) — killing and respawning`);
-                yield (0, process_1.killProcess)(stalePid);
-                yield new Promise((r) => setTimeout(r, 500));
-                yield this.ensureMlxServer();
-            }
-            catch (err) {
-                console.error(`[daemon] MLX recovery failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            finally {
-                this.mlxRecoveryInFlight = false;
-            }
-        });
-    }
-    ensureMlxServer(mlxModel) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (yield this.isMlxServerUp()) {
-                console.log("[daemon] MLX embed server already running");
-                return;
-            }
-            // Kill stale process holding the port (orphaned from a previous daemon)
-            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
-            const stalePid = this.getPortPid(port);
-            if (stalePid) {
-                console.log(`[daemon] Killing stale MLX process on port ${port} (PID: ${stalePid})`);
-                yield (0, process_1.killProcess)(stalePid);
-                // Brief pause for OS to release the port
-                yield new Promise((r) => setTimeout(r, 500));
-            }
-            // Find mlx-embed-server/server.py relative to the grepmax package
-            const candidates = [
-                path.resolve(__dirname, "../../../mlx-embed-server"),
-                path.resolve(__dirname, "../../mlx-embed-server"),
-            ];
-            const serverDir = candidates.find((d) => fs.existsSync(path.join(d, "server.py")));
-            if (!serverDir) {
-                console.warn("[daemon] MLX embed server not found — falling back to CPU embeddings");
-                return;
-            }
-            const logFd = (0, log_rotate_1.openRotatedLog)(path.join(config_1.PATHS.logsDir, "mlx-embed-server.log"));
-            const env = Object.assign({}, process.env);
-            if (mlxModel)
-                env.MLX_EMBED_MODEL = mlxModel;
-            this.mlxChild = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
-                cwd: serverDir,
-                detached: true,
-                stdio: ["ignore", logFd, logFd],
-                env,
-            });
-            this.mlxChild.unref();
-            console.log(`[daemon] Starting MLX embed server (PID: ${this.mlxChild.pid})`);
-            // Poll for readiness (up to 30s)
-            for (let i = 0; i < 30; i++) {
-                yield new Promise((r) => setTimeout(r, 1000));
-                if (yield this.isMlxServerUp()) {
-                    console.log("[daemon] MLX embed server ready");
-                    return;
-                }
-            }
-            console.error("[daemon] MLX embed server failed to start within 30s — falling back to CPU embeddings");
-            this.mlxChild = null;
-        });
-    }
-    stopMlxServer() {
-        var _a;
-        // The spawned process is `uv`, which forks `python` then exits. Killing the
-        // recorded PID alone leaves python orphaned (the orphan source for port 8100
-        // collisions across daemon restarts). Always also kill whoever owns the port.
-        if ((_a = this.mlxChild) === null || _a === void 0 ? void 0 : _a.pid) {
-            try {
-                process.kill(-this.mlxChild.pid, "SIGTERM");
-            }
-            catch (_b) {
-                try {
-                    process.kill(this.mlxChild.pid, "SIGTERM");
-                }
-                catch (_c) { }
-            }
-            console.log(`[daemon] Stopped MLX embed server (PID: ${this.mlxChild.pid})`);
-            this.mlxChild = null;
-        }
-        const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
-        const portOwner = this.getPortPid(port);
-        if (portOwner) {
-            try {
-                process.kill(portOwner, "SIGTERM");
-                console.log(`[daemon] Killed orphan MLX on port ${port} (PID: ${portOwner})`);
-            }
-            catch (_d) { }
-        }
-    }
-    /**
-     * Find and kill all stale gmax-daemon and gmax-worker processes.
-     * Uses pgrep to scan by process title rather than relying solely on
-     * the PID file, which becomes stale when a daemon is orphaned through
-     * the lock-compromise path.
-     */
     /**
      * Gracefully hand off to a fresh daemon when this one has grown too old or
      * too large. Only fires when quiet — no active compaction and no in-flight
@@ -1324,104 +823,6 @@ class Daemon {
         this.recycling = true;
         void this.shutdown({ relaunch: true }).finally(() => process.exit(0));
     }
-    /**
-     * Kill gmax-worker processes that are children of THIS daemon but the worker
-     * pool no longer tracks — strays left behind if a kill ever failed silently.
-     * Filters by parent PID so a per-project `gmax watch`'s own workers are never
-     * touched. Requires a worker to look orphaned on two consecutive sweeps so a
-     * just-forked worker can't be killed by a snapshot race.
-     */
-    sweepOrphanWorkers() {
-        if (this.shuttingDown || !(0, pool_1.isWorkerPoolInitialized)())
-            return;
-        const tracked = new Set((0, pool_1.getWorkerPool)().getWorkerPids());
-        const workerPids = new Set(this.findProcessesByTitle("gmax-worker"));
-        const ourChildren = this.findChildPids();
-        const orphans = ourChildren.filter((pid) => workerPids.has(pid) && !tracked.has(pid));
-        const confirmed = orphans.filter((pid) => this.suspectedOrphanWorkers.has(pid));
-        this.suspectedOrphanWorkers = new Set(orphans);
-        for (const pid of confirmed) {
-            console.log(`[daemon] Killing orphan worker PID:${pid} (untracked by pool)`);
-            try {
-                process.kill(pid, "SIGKILL");
-            }
-            catch (_a) { }
-            this.suspectedOrphanWorkers.delete(pid);
-        }
-    }
-    /** Child PIDs of this process (workers, MLX, llama-server). */
-    findChildPids() {
-        try {
-            const out = (0, node_child_process_1.execSync)(`pgrep -P ${process.pid}`, {
-                timeout: 5000,
-                encoding: "utf-8",
-            }).trim();
-            if (!out)
-                return [];
-            return out
-                .split("\n")
-                .map((s) => parseInt(s.trim(), 10))
-                .filter((n) => Number.isFinite(n) && n > 0);
-        }
-        catch (_a) {
-            return [];
-        }
-    }
-    killStaleProcesses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 1. Check for other daemon processes
-            const daemonPids = this.findProcessesByTitle("gmax-daemon")
-                .filter((pid) => pid !== process.pid);
-            const workerPids = this.findProcessesByTitle("gmax-worker");
-            if (daemonPids.length === 0 && workerPids.length === 0) {
-                (0, logger_1.log)("daemon", "No stale processes found");
-                return;
-            }
-            for (const pid of daemonPids) {
-                (0, logger_1.log)("daemon", `found daemon PID:${pid}, checking liveness...`);
-                // A busy daemon (mid-index, compaction, big LMDB write) can block the
-                // event loop long enough to miss a ping. Two independent liveness
-                // probes — if either says "alive", defer to the running peer instead
-                // of killing its workers mid-flight.
-                //   1. daemon.lock mtime (refreshed by heartbeat every 60s)
-                //   2. socket ping with a generous 10s timeout
-                const heartbeatFresh = (0, daemon_client_1.isDaemonHeartbeatFresh)();
-                const responsive = yield (0, daemon_client_1.isDaemonRunning)({ timeoutMs: 10000 });
-                if (heartbeatFresh || responsive) {
-                    (0, logger_1.log)("daemon", `existing daemon PID:${pid} is alive (heartbeat=${heartbeatFresh} ping=${responsive}) — exiting`);
-                    process.exit(0);
-                }
-                (0, logger_1.log)("daemon", `stale daemon PID:${pid} unresponsive and heartbeat stale — killing`);
-                yield (0, process_1.killProcess)(pid);
-                (0, logger_1.log)("daemon", `killed stale daemon PID:${pid}`);
-            }
-            // 2. Kill orphaned workers from previous daemon instances.
-            // Safe because this runs before the new daemon's worker pool is initialized.
-            for (const pid of workerPids) {
-                (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
-                yield (0, process_1.killProcess)(pid);
-            }
-            (0, logger_1.log)("daemon", `Cleaned up ${daemonPids.length} stale daemon(s), ${workerPids.length} orphaned worker(s)`);
-        });
-    }
-    findProcessesByTitle(title) {
-        try {
-            const out = (0, node_child_process_1.execSync)(`pgrep -x "${title}"`, {
-                timeout: 5000,
-                encoding: "utf-8",
-            }).trim();
-            if (!out)
-                return [];
-            return out
-                .split("\n")
-                .map((s) => parseInt(s.trim(), 10))
-                .filter((n) => Number.isFinite(n) && n > 0);
-        }
-        catch (_a) {
-            // pgrep exits 1 when no processes match — not an error
-            return [];
-        }
-    }
     shutdown() {
         return __awaiter(this, arguments, void 0, function* (opts = {}) {
             var _a, _b, _c, _d;
@@ -1471,7 +872,7 @@ class Daemon {
             }
             catch (_g) { }
             // Stop MLX embed server if we started it
-            this.stopMlxServer();
+            this.mlxServerManager.stopMlxServer();
             // Destroy worker pool to prevent orphaned child processes
             if ((0, pool_1.isWorkerPoolInitialized)()) {
                 try {
@@ -1479,23 +880,8 @@ class Daemon {
                 }
                 catch (_h) { }
             }
-            // Stop poll intervals + their FSEvents recovery probes
-            for (const interval of this.pollIntervals.values()) {
-                clearInterval(interval);
-            }
-            this.pollIntervals.clear();
-            for (const interval of this.pollRecoveryTimers.values()) {
-                clearInterval(interval);
-            }
-            this.pollRecoveryTimers.clear();
-            // Unsubscribe all watchers
-            for (const sub of this.subscriptions.values()) {
-                try {
-                    yield sub.unsubscribe();
-                }
-                catch (_j) { }
-            }
-            this.subscriptions.clear();
+            // Stop watcher poll intervals + FSEvents recovery probes, unsubscribe all
+            yield this.watcherManager.teardown();
             // Close server (socket/pid/lock already dropped at the top of shutdown)
             (_b = this.server) === null || _b === void 0 ? void 0 : _b.close();
             // Unregister all
@@ -1508,11 +894,11 @@ class Daemon {
             try {
                 yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_k) { }
+            catch (_j) { }
             try {
                 yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
             }
-            catch (_l) { }
+            catch (_k) { }
             // Hand off to a successor only after every resource is released and the
             // liveness markers (socket/pid/lock) are already gone — so the fresh
             // daemon's singleton check sees a clean slate and opens LanceDB/LMDB