grepmax 0.24.0 → 0.25.0

package/dist/lib/daemon/daemon.js

@@ -51,15 +51,20 @@ const net = __importStar(require("node:net"));
 const path = __importStar(require("node:path"));
 const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
 const config_1 = require("../../config");
+const embedding_generation_1 = require("../index/embedding-generation");
+const embedding_status_1 = require("../index/embedding-status");
 const index_config_1 = require("../index/index-config");
 const syncer_1 = require("../index/syncer");
 const server_1 = require("../llm/server");
 const meta_cache_1 = require("../store/meta-cache");
+const store_lease_1 = require("../store/store-lease");
 const vector_db_1 = require("../store/vector-db");
 const daemon_client_1 = require("../utils/daemon-client");
 const daemon_launcher_1 = require("../utils/daemon-launcher");
+const keyed_mutex_1 = require("../utils/keyed-mutex");
 const log_rotate_1 = require("../utils/log-rotate");
 const logger_1 = require("../utils/logger");
+const operation_coordinator_1 = require("../utils/operation-coordinator");
 const process_1 = require("../utils/process");
 const project_registry_1 = require("../utils/project-registry");
 const watcher_store_1 = require("../utils/watcher-store");
@@ -107,8 +112,14 @@ class Daemon {
         this.searchers = new Map();
         this.subscriptions = new Map();
         this.vectorDb = null;
+        this.activeConfig = null;
+        this.activeGeneration = null;
+        this.workerPool = null;
+        this.resources = null;
+        this.nextResourceGenerationId = 1;
         this.metaCache = null;
         this.server = null;
+        this.connections = new Set();
         this.releaseLock = null;
         this.lastActivity = Date.now();
         this.startTime = Date.now();
@@ -123,6 +134,7 @@ class Daemon {
         this.ready = false;
         this.processManager = new process_manager_1.ProcessManager({
             getShuttingDown: () => this.shuttingDown,
+            getWorkerPids: () => { var _a; return (_a = this.workerPool) === null || _a === void 0 ? void 0 : _a.getWorkerPids(); },
         });
         this.mlxServerManager = new mlx_server_manager_1.MlxServerManager({
             getShuttingDown: () => this.shuttingDown,
@@ -132,6 +144,7 @@ class Daemon {
             subscriptions: this.subscriptions,
             getVectorDb: () => this.vectorDb,
             getMetaCache: () => this.metaCache,
+            getWorkerPool: () => this.workerPool,
             getShuttingDown: () => this.shuttingDown,
             touchActivity: () => {
                 this.lastActivity = Date.now();
@@ -139,20 +152,63 @@ class Daemon {
             evictSearcher: (root) => {
                 this.searchers.delete(root);
             },
+            runProjectOperation: (root, name, signal, fn) => this.withProjectLock(root, signal, () => this.runSharedOperation(name, signal, fn)),
         });
-        this.projectLocks = new Map();
+        this.projectMutex = new keyed_mutex_1.KeyedMutex();
+        this.operations = new operation_coordinator_1.OperationCoordinator();
+        this.shutdownPromise = null;
         // Full-index progress per root while initialSync runs (--reset / initial
         // index). Presence = a full index is in flight; value drives the partial-
         // result pending count (Phase 6). Cleared in the indexProject finally.
         this.indexProgress = new Map();
         this.shutdownAbortControllers = new Set();
+        this.pendingIndexRetryTimers = new Map();
+        this.pendingIndexRetryCounts = new Map();
         this.llmServer = null;
     }
+    assertStartupActive() {
+        if (this.shuttingDown)
+            throw new operation_coordinator_1.OperationClosedError();
+    }
+    createWorkerPool(generation, embedMode) {
+        return new pool_1.WorkerPool(generation, embedMode);
+    }
+    createVectorDb(vectorDim, lease) {
+        return new vector_db_1.VectorDB(config_1.PATHS.lancedbDir, vectorDim, lease);
+    }
+    mlxMode(config) {
+        if (config.embedMode !== "gpu")
+            return "cpu";
+        const state = this.mlxServerManager.getStatus().state;
+        return state === "owned-ready"
+            ? "owned"
+            : state === "adopted-ready"
+                ? "adopted"
+                : "cpu";
+    }
+    publishResourceGeneration(config, embedding, vectorDb, workerPool, mlx) {
+        const resources = Object.freeze({
+            id: this.nextResourceGenerationId++,
+            config: Object.freeze(Object.assign({}, config)),
+            embedding,
+            vectorDb,
+            workerPool,
+            mlx,
+        });
+        this.activeConfig = resources.config;
+        this.activeGeneration = resources.embedding;
+        this.vectorDb = resources.vectorDb;
+        this.workerPool = resources.workerPool;
+        this.resources = resources;
+        return resources;
+    }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             process.title = "gmax-daemon";
             // 0. Singleton enforcement: find and kill ALL stale daemon/worker processes
             yield this.processManager.killStaleProcesses();
+            this.assertStartupActive();
             // 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
@@ -169,6 +225,7 @@ class Daemon {
                         this.shutdown().finally(() => process.exit(0));
                     },
                 });
+                this.assertStartupActive();
                 (0, logger_1.debug)("daemon", "lock acquired");
             }
             catch (err) {
@@ -187,9 +244,11 @@ class Daemon {
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_a) { }
+            catch (_b) { }
             this.server = net.createServer((conn) => {
                 (0, logger_1.debug)("daemon", "client connected");
+                this.connections.add(conn);
+                conn.once("close", () => this.connections.delete(conn));
                 let buf = "";
                 conn.on("data", (chunk) => {
                     buf += chunk.toString();
@@ -239,6 +298,7 @@ class Daemon {
                 });
                 this.server.listen(config_1.PATHS.daemonSocket, () => resolve());
             });
+            this.assertStartupActive();
             // 3. Write PID file AFTER socket is listening — ensures any process that
             // reads the PID can immediately ping this daemon and get a response.
             fs.writeFileSync(config_1.PATHS.daemonPidFile, String(process.pid));
@@ -247,6 +307,7 @@ class Daemon {
             for (const w of existing) {
                 console.log(`[daemon] Taking over from per-project watcher (PID: ${w.pid}, ${path.basename(w.projectRoot)})`);
                 yield (0, process_1.killProcess)(w.pid);
+                this.assertStartupActive();
                 (0, watcher_store_1.unregisterWatcher)(w.pid);
             }
             // 5. Open shared resources
@@ -254,10 +315,14 @@ class Daemon {
                 fs.mkdirSync(config_1.PATHS.cacheDir, { recursive: true });
                 fs.mkdirSync(config_1.PATHS.lancedbDir, { recursive: true });
                 console.log("[daemon] Opening LanceDB:", config_1.PATHS.lancedbDir);
-                this.vectorDb = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
-                this.vectorDb.startMaintenanceLoop();
+                this.activeConfig = (0, index_config_1.readGlobalConfig)();
+                this.activeGeneration = (0, embedding_generation_1.resolveEmbeddingGeneration)(this.activeConfig);
+                this.vectorDb = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir, this.activeGeneration.vectorDim);
+                this.workerPool = this.createWorkerPool(this.activeGeneration, this.activeConfig.embedMode);
+                this.vectorDb.startMaintenanceLoop((fn) => this.runSharedOperation("store-maintenance", undefined, () => fn()));
                 console.log("[daemon] Opening MetaCache:", config_1.PATHS.lmdbPath);
                 this.metaCache = new meta_cache_1.MetaCache(config_1.PATHS.lmdbPath);
+                this.assertStartupActive();
                 // Resources are open — only now may resource-dependent IPC commands run.
                 this.ready = true;
             }
@@ -268,11 +333,13 @@ class Daemon {
             // 6. LLM server manager (constructed, not started — starts on first request)
             this.llmServer = new server_1.LlmServer();
             // 6b. MLX embed server — start if GPU mode is active
-            const globalConfig = (0, index_config_1.readGlobalConfig)();
+            const globalConfig = (_a = this.activeConfig) !== null && _a !== void 0 ? _a : (0, index_config_1.readGlobalConfig)();
             const isAppleSilicon = process.arch === "arm64" && process.platform === "darwin";
             if (isAppleSilicon && globalConfig.embedMode === "gpu") {
                 yield this.mlxServerManager.ensureMlxServer(globalConfig.mlxModel);
+                this.assertStartupActive();
             }
+            this.publishResourceGeneration(globalConfig, this.activeGeneration, this.vectorDb, this.workerPool, this.mlxMode(globalConfig));
             // 7. Register daemon (only after resources are open)
             (0, watcher_store_1.registerDaemon)(process.pid);
             // 8. Subscribe to all registered projects (skip missing directories)
@@ -285,6 +352,7 @@ class Daemon {
                 }
                 try {
                     yield this.watchProject(p.root);
+                    this.assertStartupActive();
                 }
                 catch (err) {
                     console.error(`[daemon] Failed to watch ${path.basename(p.root)}:`, err);
@@ -297,6 +365,7 @@ class Daemon {
             // snapshot, so a new project op kicked off after the snapshot would race
             // with vectorDb.close() and fail with "VectorDB connection is closed".
             const pending = allProjects.filter((p) => (p.status === "pending" || p.status === "error") &&
+                !p.rebuildId &&
                 fs.existsSync(p.root));
             void (() => __awaiter(this, void 0, void 0, function* () {
                 for (const p of pending) {
@@ -365,15 +434,16 @@ class Daemon {
             setTimeout(() => {
                 if (this.shuttingDown)
                     return;
-                void (() => __awaiter(this, void 0, void 0, function* () {
+                void this.runSharedOperation("search-warmup", undefined, () => __awaiter(this, void 0, void 0, function* () {
                     const t0 = Date.now();
                     try {
                         if (this.vectorDb) {
                             yield this.vectorDb.ensureTable();
                             yield this.vectorDb.createFTSIndex();
                         }
-                        const { getWorkerPool } = yield Promise.resolve().then(() => __importStar(require("../workers/pool")));
-                        const pool = getWorkerPool();
+                        const pool = this.workerPool;
+                        if (!pool)
+                            throw new Error("worker pool not ready");
                         // Two parallel encodes force the pool to spawn two workers and
                         // warm both (each worker loads Granite + ColBERT lazily on first
                         // encode — once warmed, subsequent encodes are ~13ms).
@@ -386,64 +456,154 @@ class Daemon {
                     catch (err) {
                         console.log(`[daemon] Search warmup failed (non-fatal): ${err}`);
                     }
-                }))();
+                })).catch((err) => {
+                    if (err instanceof operation_coordinator_1.OperationClosedError)
+                        return;
+                    console.log(`[daemon] Search warmup skipped: ${err}`);
+                });
             }, 5000).unref();
         });
     }
-    watchProject(root) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.watcherManager.watchProject(root);
-        });
+    watchProject(root, signal) {
+        return this.withProjectLock(root, signal, () => this.runSharedOperation("watch", signal, () => this.watchProjectWithinOperation(root)));
+    }
+    watchProjectWithinOperation(root) {
+        return this.watcherManager.watchProject(root);
+    }
+    runSharedOperation(name, signal, fn) {
+        return this.operations.runShared(name, signal, fn);
+    }
+    operationStatus() {
+        return this.operations.status;
+    }
+    resourceGenerationId() {
+        var _a, _b;
+        return (_b = (_a = this.resources) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
+    }
+    hasUnfinishedRebuild() {
+        try {
+            return (0, project_registry_1.hasUnfinishedProjectRebuild)();
+        }
+        catch (_a) {
+            return true;
+        }
+    }
+    schedulePendingIndexRetry(root) {
+        var _a;
+        if (this.shuttingDown || this.pendingIndexRetryTimers.has(root))
+            return;
+        const attempts = (_a = this.pendingIndexRetryCounts.get(root)) !== null && _a !== void 0 ? _a : 0;
+        if (attempts >= 5)
+            return;
+        this.pendingIndexRetryCounts.set(root, attempts + 1);
+        const timer = setTimeout(() => {
+            this.pendingIndexRetryTimers.delete(root);
+            if (!this.shuttingDown)
+                void this.indexPendingProject(root);
+        }, 30000);
+        timer.unref();
+        this.pendingIndexRetryTimers.set(root, timer);
+    }
+    clearPendingIndexRetry(root) {
+        const timer = this.pendingIndexRetryTimers.get(root);
+        if (timer)
+            clearTimeout(timer);
+        this.pendingIndexRetryTimers.delete(root);
+        this.pendingIndexRetryCounts.delete(root);
     }
     indexPendingProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                // Bail if shutdown raced ahead of us between IIFE iteration and lock
-                // acquisition — otherwise we'd start writing to a DB that shutdown is
-                // about to close, leaving the project status as "error".
-                if (this.shuttingDown)
-                    return;
-                if (!this.vectorDb || !this.metaCache)
-                    return;
-                const name = path.basename(root);
-                const start = Date.now();
-                (0, logger_1.log)("daemon", `indexPendingProject start: ${name} (${root})`);
-                this.vectorDb.pauseMaintenanceLoop();
-                try {
-                    const result = yield (0, syncer_1.initialSync)({
-                        projectRoot: root,
-                        vectorDb: this.vectorDb,
-                        metaCache: this.metaCache,
-                        onProgress: () => {
-                            this.resetActivity();
-                        },
-                    });
-                    const proj = (0, project_registry_1.getProject)(root);
-                    if (proj) {
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { lastIndexed: new Date().toISOString(), chunkCount: result.indexed, status: "indexed", chunkerVersion: config_1.CONFIG.CHUNKER_VERSION }));
-                    }
-                    yield this.watchProject(root);
-                    (0, logger_1.log)("daemon", `indexPendingProject done: ${name} — ${result.total} files, ${result.indexed} chunks, ${Date.now() - start}ms`);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`[daemon] indexPendingProject failed for ${name} after ${Date.now() - start}ms: ${msg}`);
-                    const proj = (0, project_registry_1.getProject)(root);
-                    if (proj) {
-                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { status: "error" }));
-                    }
-                }
-                finally {
-                    (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
-                }
-            }));
+            const ac = new AbortController();
+            this.shutdownAbortControllers.add(ac);
+            try {
+                yield this.withProjectLock(root, ac.signal, () => __awaiter(this, void 0, void 0, function* () {
+                    return this.runSharedOperation("index-pending", ac.signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b, _c, _d;
+                        // Bail if shutdown raced ahead of us between iteration and lock
+                        // acquisition. Starting now would race the store close below.
+                        if (this.shuttingDown)
+                            return;
+                        if (!this.vectorDb || !this.metaCache)
+                            return;
+                        const current = (0, project_registry_1.getProject)(root);
+                        if ((current === null || current === void 0 ? void 0 : current.status) !== "pending" && (current === null || current === void 0 ? void 0 : current.status) !== "error")
+                            return;
+                        const name = path.basename(root);
+                        const start = Date.now();
+                        (0, logger_1.log)("daemon", `indexPendingProject start: ${name} (${root})`);
+                        this.vectorDb.pauseMaintenanceLoop();
+                        try {
+                            if (this.processors.has(root))
+                                yield this.unwatchProjectWithinOperation(root);
+                            const result = yield (0, syncer_1.initialSync)({
+                                projectRoot: root,
+                                vectorDb: this.vectorDb,
+                                metaCache: this.metaCache,
+                                signal: operationSignal,
+                                generation: (_a = this.activeGeneration) !== null && _a !== void 0 ? _a : undefined,
+                                embedMode: (_b = this.activeConfig) === null || _b === void 0 ? void 0 : _b.embedMode,
+                                workerPool: (_c = this.workerPool) !== null && _c !== void 0 ? _c : undefined,
+                                onProgress: () => {
+                                    this.resetActivity();
+                                },
+                            });
+                            const prefix = root.endsWith("/") ? root : `${root}/`;
+                            const chunkCount = yield this.vectorDb.countRowsForPath(prefix);
+                            const proj = (0, project_registry_1.getProject)(root);
+                            if (proj) {
+                                if (result.degraded) {
+                                    (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { status: "pending" }));
+                                    this.schedulePendingIndexRetry(root);
+                                }
+                                else {
+                                    this.clearPendingIndexRetry(root);
+                                    (0, project_registry_1.stampProjectFullSync)({
+                                        root,
+                                        name: proj.name,
+                                        generation: result.generation,
+                                        embedMode: result.embedMode,
+                                        chunkCount,
+                                        chunkerVersion: config_1.CONFIG.CHUNKER_VERSION,
+                                        expectedFingerprint: result.registryExpectation.embeddingFingerprint,
+                                        expectedRebuildId: result.registryExpectation.rebuildId,
+                                    });
+                                }
+                            }
+                            (0, logger_1.log)("daemon", `indexPendingProject done: ${name} — ${result.total} files, ${result.indexed} chunks, ${Date.now() - start}ms`);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            console.error(`[daemon] indexPendingProject failed for ${name} after ${Date.now() - start}ms: ${msg}`);
+                            const proj = (0, project_registry_1.getProject)(root);
+                            if (proj && !(err instanceof project_registry_1.ProjectRegistryConflictError)) {
+                                (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { status: "error" }));
+                                this.schedulePendingIndexRetry(root);
+                            }
+                        }
+                        finally {
+                            (_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.resumeMaintenanceLoop();
+                            if (!this.shuttingDown) {
+                                try {
+                                    yield this.watchProjectWithinOperation(root);
+                                }
+                                catch (err) {
+                                    console.error(`[daemon] Failed to re-watch ${name}:`, err);
+                                }
+                            }
+                        }
+                    }));
+                }));
+            }
+            finally {
+                this.shutdownAbortControllers.delete(ac);
+            }
         });
     }
-    unwatchProject(root) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.watcherManager.unwatchProject(root);
-        });
+    unwatchProject(root, signal) {
+        return this.withProjectLock(root, signal, () => this.runSharedOperation("unwatch", signal, () => this.unwatchProjectWithinOperation(root)));
+    }
+    unwatchProjectWithinOperation(root) {
+        return this.watcherManager.unwatchProject(root);
     }
     /**
      * Run a search inside the daemon, reusing the warm VectorDB connection,
@@ -485,16 +645,20 @@ class Daemon {
             // Search handling lives in search-handler.ts (Phase 12 split). The daemon
             // supplies its warm VectorDB + watcher/index bookkeeping; the handler runs
             // the query and assembles the response.
-            return (0, search_handler_1.handleDaemonSearch)({
-                vectorDb: this.vectorDb,
-                processors: this.processors,
-                indexProgress: this.indexProgress,
-                searchers: this.searchers,
-                getIndexState: (root) => this.indexState(root),
-                touchActivity: () => {
-                    this.lastActivity = Date.now();
-                },
-            }, payload, signal);
+            return this.runSharedOperation("search", signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                return (0, search_handler_1.handleDaemonSearch)({
+                    vectorDb: this.vectorDb,
+                    processors: this.processors,
+                    indexProgress: this.indexProgress,
+                    searchers: this.searchers,
+                    getIndexState: (root) => this.indexState(root),
+                    touchActivity: () => {
+                        this.lastActivity = Date.now();
+                    },
+                    generation: this.activeGeneration,
+                    workerPool: this.workerPool,
+                }, payload, operationSignal);
+            }));
         });
     }
     listProjects() {
@@ -514,90 +678,250 @@ class Daemon {
         var _a, _b;
         return (_b = (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.diskPressure) !== null && _b !== void 0 ? _b : "unknown";
     }
+    getMlxStatus() {
+        return this.mlxServerManager.getStatus();
+    }
     /** Reset idle timer — call during long-running operations. */
     resetActivity() {
         this.lastActivity = Date.now();
     }
     // --- Per-project operation serialization ---
-    withProjectLock(root, fn) {
+    withProjectLock(root, signal, fn) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const prev = (_a = this.projectLocks.get(root)) !== null && _a !== void 0 ? _a : Promise.resolve();
-            let release;
-            const next = new Promise((r) => {
-                release = r;
-            });
-            this.projectLocks.set(root, next);
-            yield prev;
+            return this.projectMutex.run(root, signal, fn);
+        });
+    }
+    // --- Streaming write operations (IPC) ---
+    activeConfigurationError() {
+        const activeConfig = this.activeConfig;
+        const activeGeneration = this.activeGeneration;
+        if (!activeConfig || !activeGeneration)
+            return "daemon resources not ready";
+        const currentConfig = (0, index_config_1.readGlobalConfig)();
+        let currentGeneration;
+        try {
+            currentGeneration = (0, embedding_generation_1.resolveEmbeddingGeneration)(currentConfig);
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+        return currentGeneration.fingerprint !== activeGeneration.fingerprint ||
+            currentConfig.embedMode !== activeConfig.embedMode ||
+            currentConfig.mlxModel !== activeConfig.mlxModel
+            ? "daemon configuration is stale; restart the gmax daemon"
+            : null;
+    }
+    ensureProject(root, conn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ac = new AbortController();
+            const onClose = () => ac.abort();
+            conn.once("close", onClose);
+            this.shutdownAbortControllers.add(ac);
             try {
-                return yield fn();
+                yield this.withProjectLock(root, ac.signal, () => this.runSharedOperation("ensure-project", ac.signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (operationSignal.aborted || this.shuttingDown)
+                        return;
+                    const activeConfig = this.activeConfig;
+                    const configurationError = this.activeConfigurationError();
+                    if (!activeConfig || configurationError) {
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: false,
+                            error: configurationError !== null && configurationError !== void 0 ? configurationError : "daemon resources not ready",
+                        });
+                        return;
+                    }
+                    const project = (0, project_registry_1.getProject)(root);
+                    if ((project === null || project === void 0 ? void 0 : project.status) === "indexed") {
+                        if (!this.activeGeneration ||
+                            (0, embedding_generation_1.compareEmbeddingGeneration)(project, this.activeGeneration)
+                                .state === "stale") {
+                            (0, ipc_handler_1.writeDone)(conn, {
+                                ok: false,
+                                error: "project embedding generation is stale; rebuild the project",
+                            });
+                            return;
+                        }
+                        yield this.watchProjectWithinOperation(root);
+                        (0, ipc_handler_1.writeDone)(conn, { ok: true, status: "indexed", watched: true });
+                        return;
+                    }
+                    (0, project_registry_1.registerProject)({
+                        root,
+                        name: (_a = project === null || project === void 0 ? void 0 : project.name) !== null && _a !== void 0 ? _a : path.basename(root),
+                        vectorDim: activeConfig.vectorDim,
+                        modelTier: activeConfig.modelTier,
+                        embedMode: activeConfig.embedMode,
+                        lastIndexed: (_b = project === null || project === void 0 ? void 0 : project.lastIndexed) !== null && _b !== void 0 ? _b : "",
+                        chunkCount: project === null || project === void 0 ? void 0 : project.chunkCount,
+                        status: "pending",
+                        chunkerVersion: project === null || project === void 0 ? void 0 : project.chunkerVersion,
+                    });
+                    yield this.addProjectLocked(root, conn, operationSignal, project);
+                })));
             }
             finally {
-                release();
-                if (this.projectLocks.get(root) === next) {
-                    this.projectLocks.delete(root);
-                }
+                conn.off("close", onClose);
+                this.shutdownAbortControllers.delete(ac);
             }
         });
     }
-    // --- Streaming write operations (IPC) ---
     addProject(root, conn) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                if (!this.vectorDb || !this.metaCache) {
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
-                    return;
-                }
-                const ac = new AbortController();
-                conn.on("close", () => ac.abort());
-                this.shutdownAbortControllers.add(ac);
-                this.vectorDb.pauseMaintenanceLoop();
-                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
-                let lastProgressTime = 0;
-                try {
-                    const result = yield (0, syncer_1.initialSync)({
-                        projectRoot: root,
-                        vectorDb: this.vectorDb,
-                        metaCache: this.metaCache,
-                        signal: ac.signal,
-                        onProgress: (info) => {
-                            this.resetActivity();
-                            const now = Date.now();
-                            if (now - lastProgressTime < 100)
-                                return;
-                            lastProgressTime = now;
-                            (0, ipc_handler_1.writeProgress)(conn, {
-                                processed: info.processed,
-                                indexed: info.indexed,
-                                total: info.total,
-                                filePath: info.filePath,
-                            });
-                        },
-                    });
-                    if (!this.shuttingDown) {
-                        yield this.watchProject(root);
+            const ac = new AbortController();
+            const onClose = () => ac.abort();
+            conn.once("close", onClose);
+            this.shutdownAbortControllers.add(ac);
+            try {
+                yield this.withProjectLock(root, ac.signal, () => this.runSharedOperation("add-project", ac.signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                    if (operationSignal.aborted || this.shuttingDown)
+                        return;
+                    const configurationError = this.activeConfigurationError();
+                    if (configurationError) {
+                        (0, ipc_handler_1.writeDone)(conn, { ok: false, error: configurationError });
+                        return;
                     }
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, {
-                        ok: true,
-                        processed: result.processed,
-                        indexed: result.indexed,
-                        total: result.total,
-                        failedFiles: result.failedFiles,
+                    yield this.addProjectLocked(root, conn, operationSignal, (0, project_registry_1.getProject)(root));
+                })));
+            }
+            finally {
+                conn.off("close", onClose);
+                this.shutdownAbortControllers.delete(ac);
+            }
+        });
+    }
+    addProjectLocked(root, conn, signal, previousProject) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.vectorDb || !this.metaCache || !this.activeConfig) {
+                (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
+                return;
+            }
+            if (!(0, project_registry_1.getProject)(root)) {
+                (0, project_registry_1.registerProject)({
+                    root,
+                    name: path.basename(root),
+                    vectorDim: this.activeConfig.vectorDim,
+                    modelTier: this.activeConfig.modelTier,
+                    embedMode: this.activeConfig.embedMode,
+                    lastIndexed: "",
+                    status: "pending",
+                });
+            }
+            this.vectorDb.pauseMaintenanceLoop();
+            const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
+            let lastProgressTime = 0;
+            try {
+                const result = yield (0, syncer_1.initialSync)({
+                    projectRoot: root,
+                    vectorDb: this.vectorDb,
+                    metaCache: this.metaCache,
+                    signal,
+                    generation: (_a = this.activeGeneration) !== null && _a !== void 0 ? _a : undefined,
+                    embedMode: this.activeConfig.embedMode,
+                    workerPool: (_b = this.workerPool) !== null && _b !== void 0 ? _b : undefined,
+                    onProgress: (info) => {
+                        this.resetActivity();
+                        const now = Date.now();
+                        if (now - lastProgressTime < 100)
+                            return;
+                        lastProgressTime = now;
+                        (0, ipc_handler_1.writeProgress)(conn, {
+                            processed: info.processed,
+                            indexed: info.indexed,
+                            total: info.total,
+                            filePath: info.filePath,
+                        });
+                    },
+                });
+                if (signal.aborted || this.shuttingDown) {
+                    const abortError = new Error("Aborted");
+                    abortError.name = "AbortError";
+                    throw abortError;
+                }
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                const chunkCount = yield this.vectorDb.countRowsForPath(prefix);
+                const project = (0, project_registry_1.getProject)(root);
+                if (result.degraded) {
+                    if (previousProject)
+                        (0, project_registry_1.registerProject)(previousProject);
+                    this.schedulePendingIndexRetry(root);
+                }
+                else {
+                    this.clearPendingIndexRetry(root);
+                    (0, project_registry_1.stampProjectFullSync)({
+                        root,
+                        name: (_c = project === null || project === void 0 ? void 0 : project.name) !== null && _c !== void 0 ? _c : path.basename(root),
+                        generation: result.generation,
+                        embedMode: result.embedMode,
+                        chunkCount,
+                        chunkerVersion: config_1.CONFIG.CHUNKER_VERSION,
+                        expectedFingerprint: result.registryExpectation.embeddingFingerprint,
+                        expectedRebuildId: result.registryExpectation.rebuildId,
                     });
                 }
-                catch (err) {
+                yield this.watchProjectWithinOperation(root);
+                (0, ipc_handler_1.writeDone)(conn, {
+                    ok: true,
+                    processed: result.processed,
+                    indexed: result.indexed,
+                    total: result.total,
+                    failedFiles: result.failedFiles,
+                    degraded: result.degraded,
+                    scanErrors: result.scanErrors,
+                });
+            }
+            catch (err) {
+                const aborted = signal.aborted || (err === null || err === void 0 ? void 0 : err.name) === "AbortError";
+                if (aborted) {
+                    if (previousProject)
+                        (0, project_registry_1.registerProject)(previousProject);
+                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "aborted" });
+                }
+                else {
                     const msg = err instanceof Error ? err.message : String(err);
                     console.error(`[daemon] addProject failed for ${path.basename(root)}:`, msg);
-                    stopHeartbeat();
+                    const project = (0, project_registry_1.getProject)(root);
+                    if (project && !(err instanceof project_registry_1.ProjectRegistryConflictError)) {
+                        (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, project), { status: "error" }));
+                    }
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
                 }
-                finally {
-                    stopHeartbeat();
-                    this.shutdownAbortControllers.delete(ac);
-                    (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
-                }
+            }
+            finally {
+                stopHeartbeat();
+                (_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.resumeMaintenanceLoop();
+            }
+        });
+    }
+    projectStats(root) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runSharedOperation("project-stats", undefined, () => __awaiter(this, void 0, void 0, function* () {
+                if (!this.vectorDb)
+                    throw new Error("daemon resources not ready");
+                const project = (0, project_registry_1.getProject)(root);
+                if (!project)
+                    throw new Error("project not registered");
+                if (!this.activeConfig)
+                    throw new Error("daemon resources not ready");
+                const identity = (0, embedding_status_1.projectEmbeddingStatus)(project, this.activeConfig);
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                const [chunks, files] = yield Promise.all([
+                    this.vectorDb.countRowsForPath(prefix),
+                    this.vectorDb.countDistinctFilesForPath(prefix),
+                ]);
+                return {
+                    files,
+                    chunks,
+                    vectorDim: project.vectorDim,
+                    modelTier: project.modelTier,
+                    embedMode: project.embedMode,
+                    indexedAt: project.lastIndexed,
+                    watching: this.processors.has(root),
+                    configuredEmbedding: identity.configured,
+                    builtEmbedding: identity.built,
+                    embeddingState: identity.state,
+                };
             }));
         });
     }
@@ -612,20 +936,13 @@ class Daemon {
      */
     reindexOneProject(root, opts, signal, onProgress) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             if (!this.vectorDb || !this.metaCache) {
                 throw new Error("daemon resources not ready");
             }
-            // Pause the project's batch processor during full index
-            const processor = this.processors.get(root);
-            if (processor) {
-                yield processor.close();
-                this.processors.delete(root);
-            }
-            const sub = this.subscriptions.get(root);
-            if (sub) {
-                yield sub.unsubscribe();
-                this.subscriptions.delete(root);
-            }
+            // Quiesce the subscription, processor, and any catchup generation before
+            // full sync takes deletion authority for this project.
+            yield this.unwatchProjectWithinOperation(root);
             // Mark this root as full-indexing so concurrent searches get a
             // partial-result footer (Phase 6); seeded at 0/0 until the first tick.
             this.indexProgress.set(root, { processed: 0, total: 0 });
@@ -637,6 +954,9 @@ class Daemon {
                     vectorDb: this.vectorDb,
                     metaCache: this.metaCache,
                     signal,
+                    generation: (_a = this.activeGeneration) !== null && _a !== void 0 ? _a : undefined,
+                    embedMode: (_b = this.activeConfig) === null || _b === void 0 ? void 0 : _b.embedMode,
+                    workerPool: (_c = this.workerPool) !== null && _c !== void 0 ? _c : undefined,
                     onProgress: (info) => {
                         this.resetActivity();
                         this.indexProgress.set(root, {
@@ -650,9 +970,9 @@ class Daemon {
             finally {
                 this.indexProgress.delete(root);
                 // Re-enable watcher (skip if shutting down)
-                if (!this.shuttingDown) {
+                if (!this.shuttingDown && opts.rewatch !== false) {
                     try {
-                        yield this.watchProject(root);
+                        yield this.watchProjectWithinOperation(root);
                     }
                     catch (err) {
                         console.error(`[daemon] Failed to re-watch ${path.basename(root)}:`, err);
@@ -663,52 +983,78 @@ class Daemon {
     }
     indexProject(root, conn, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                if (!this.vectorDb || !this.metaCache) {
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
-                    return;
-                }
-                const ac = new AbortController();
-                conn.on("close", () => ac.abort());
-                this.shutdownAbortControllers.add(ac);
-                this.vectorDb.pauseMaintenanceLoop();
-                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
-                let lastProgressTime = 0;
-                try {
-                    const result = yield this.reindexOneProject(root, opts, ac.signal, (info) => {
-                        const now = Date.now();
-                        if (now - lastProgressTime < 100)
-                            return;
-                        lastProgressTime = now;
-                        (0, ipc_handler_1.writeProgress)(conn, {
-                            processed: info.processed,
-                            indexed: info.indexed,
-                            total: info.total,
-                            filePath: info.filePath,
+            const ac = new AbortController();
+            const onClose = () => ac.abort();
+            conn.once("close", onClose);
+            this.shutdownAbortControllers.add(ac);
+            try {
+                yield this.withProjectLock(root, ac.signal, () => this.runSharedOperation("index-project", ac.signal, (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (!this.vectorDb || !this.metaCache) {
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: false,
+                            error: "daemon resources not ready",
                         });
-                    });
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, {
-                        ok: true,
-                        processed: result.processed,
-                        indexed: result.indexed,
-                        total: result.total,
-                        failedFiles: result.failedFiles,
-                    });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`[daemon] indexProject failed for ${path.basename(root)}:`, msg);
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
-                }
-                finally {
-                    stopHeartbeat();
-                    this.shutdownAbortControllers.delete(ac);
-                    (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
-                }
-            }));
+                        return;
+                    }
+                    this.vectorDb.pauseMaintenanceLoop();
+                    const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
+                    let lastProgressTime = 0;
+                    try {
+                        const result = yield this.reindexOneProject(root, opts, operationSignal, (info) => {
+                            const now = Date.now();
+                            if (now - lastProgressTime < 100)
+                                return;
+                            lastProgressTime = now;
+                            (0, ipc_handler_1.writeProgress)(conn, {
+                                processed: info.processed,
+                                indexed: info.indexed,
+                                total: info.total,
+                                filePath: info.filePath,
+                            });
+                        });
+                        if (!opts.dryRun && !result.degraded) {
+                            const prefix = root.endsWith("/") ? root : `${root}/`;
+                            const chunkCount = yield this.vectorDb.countRowsForPath(prefix);
+                            const project = (0, project_registry_1.getProject)(root);
+                            (0, project_registry_1.stampProjectFullSync)({
+                                root,
+                                generation: result.generation,
+                                embedMode: result.embedMode,
+                                chunkCount,
+                                chunkerVersion: opts.reset
+                                    ? config_1.CONFIG.CHUNKER_VERSION
+                                    : ((_a = project === null || project === void 0 ? void 0 : project.chunkerVersion) !== null && _a !== void 0 ? _a : 1),
+                                expectedFingerprint: result.registryExpectation.embeddingFingerprint,
+                                expectedRebuildId: result.registryExpectation.rebuildId,
+                            });
+                        }
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: true,
+                            processed: result.processed,
+                            indexed: result.indexed,
+                            total: result.total,
+                            failedFiles: result.failedFiles,
+                            degraded: result.degraded,
+                            scanErrors: result.scanErrors,
+                            embeddingFingerprint: result.generation.fingerprint,
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[daemon] indexProject failed for ${path.basename(root)}:`, msg);
+                        (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
+                    }
+                    finally {
+                        stopHeartbeat();
+                        (_b = this.vectorDb) === null || _b === void 0 ? void 0 : _b.resumeMaintenanceLoop();
+                    }
+                })));
+            }
+            finally {
+                conn.off("close", onClose);
+                this.shutdownAbortControllers.delete(ac);
+            }
         });
     }
     /**
@@ -724,179 +1070,508 @@ class Daemon {
     repairRebuild(conn) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!this.vectorDb || !this.metaCache) {
+            const oldResources = this.resources;
+            const metaCache = this.metaCache;
+            if (!oldResources || !metaCache) {
                 (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
                 return;
             }
-            const ac = new AbortController();
-            conn.on("close", () => ac.abort());
-            this.shutdownAbortControllers.add(ac);
-            this.vectorDb.pauseMaintenanceLoop();
+            const targetConfig = (0, index_config_1.readGlobalConfig)();
+            const targetGeneration = (0, embedding_generation_1.resolveEmbeddingGeneration)(targetConfig);
+            const clientAbort = new AbortController();
+            let dropCommitted = false;
+            let desiredWatchRoots = [];
+            let watchersRestored = false;
+            let oldPoolDestroyed = false;
+            let oldDbClosed = false;
+            const failClosedOldResources = (lease) => __awaiter(this, void 0, void 0, function* () {
+                this.ready = false;
+                this.resources = null;
+                this.vectorDb = null;
+                this.workerPool = null;
+                if (!oldPoolDestroyed) {
+                    yield oldResources.workerPool
+                        .destroy({ requireExit: true })
+                        .catch(() => { });
+                    oldPoolDestroyed = true;
+                }
+                if (!oldDbClosed) {
+                    yield oldResources.vectorDb.close().catch(() => { });
+                    oldDbClosed = true;
+                }
+                yield lease.release().catch(() => { });
+            });
+            const onClose = () => {
+                if (!dropCommitted)
+                    clientAbort.abort(new Error("client disconnected"));
+            };
+            conn.once("close", onClose);
             const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
-            // Reindex every project the daemon would normally index on startup.
-            const projects = (0, project_registry_1.listProjects)().filter((p) => p.status === "indexed" || p.status === "pending");
-            const globalConfig = (0, index_config_1.readGlobalConfig)();
-            let rebuilt = 0;
-            let totalIndexed = 0;
-            let lastProgressTime = 0;
+            const throwIfPreDropCancelled = (operationSignal) => {
+                if (operationSignal.aborted)
+                    throw operationSignal.reason;
+                if (!dropCommitted && clientAbort.signal.aborted) {
+                    throw clientAbort.signal.reason;
+                }
+            };
             try {
-                // Drop the shared table — recreated lazily at the configured width on the
-                // first insert of the reindex below.
-                (0, ipc_handler_1.writeProgress)(conn, { phase: "drop", projectsTotal: projects.length });
-                yield this.vectorDb.drop();
-                for (const p of projects) {
-                    if (ac.signal.aborted)
-                        break;
-                    const name = p.name || path.basename(p.root);
-                    yield this.withProjectLock(p.root, () => __awaiter(this, void 0, void 0, function* () {
-                        const result = yield this.reindexOneProject(p.root, { reset: true }, ac.signal, (info) => {
-                            const now = Date.now();
-                            if (now - lastProgressTime < 100)
-                                return;
-                            lastProgressTime = now;
+                const result = yield this.operations.runExclusive("repair", () => __awaiter(this, void 0, void 0, function* () {
+                    desiredWatchRoots = yield this.watcherManager.quiesceAll();
+                }), (operationSignal) => __awaiter(this, void 0, void 0, function* () {
+                    throwIfPreDropCancelled(operationSignal);
+                    oldResources.vectorDb.pauseMaintenanceLoop();
+                    this.searchers.clear();
+                    (0, ipc_handler_1.writeProgress)(conn, {
+                        phase: "lease",
+                        message: "waiting for exclusive store ownership",
+                    });
+                    let exclusiveLease = null;
+                    try {
+                        exclusiveLease = yield oldResources.vectorDb.upgradeStoreLease(AbortSignal.any([operationSignal, clientAbort.signal]));
+                        throwIfPreDropCancelled(operationSignal);
+                    }
+                    catch (error) {
+                        if (exclusiveLease) {
+                            try {
+                                yield oldResources.vectorDb.downgradeStoreLease();
+                            }
+                            catch (downgradeError) {
+                                yield failClosedOldResources(exclusiveLease);
+                                throw new Error(`Failed to restore shared store ownership: ${String(downgradeError)}`);
+                            }
+                        }
+                        oldResources.vectorDb.resumeMaintenanceLoop();
+                        throw error;
+                    }
+                    if (!exclusiveLease) {
+                        throw new Error("Exclusive store lease acquisition returned no lease");
+                    }
+                    let reservation;
+                    try {
+                        reservation = (0, project_registry_1.reserveProjectsForRebuild)(targetGeneration);
+                    }
+                    catch (error) {
+                        try {
+                            yield oldResources.vectorDb.downgradeStoreLease();
+                        }
+                        catch (downgradeError) {
+                            yield failClosedOldResources(exclusiveLease);
+                            throw new Error(`Failed to restore shared store ownership: ${String(downgradeError)}`);
+                        }
+                        oldResources.vectorDb.resumeMaintenanceLoop();
+                        throw error;
+                    }
+                    let targetDb = null;
+                    let targetPool = null;
+                    let published = false;
+                    try {
+                        (0, ipc_handler_1.writeProgress)(conn, {
+                            phase: "prepare",
+                            rebuildId: reservation.rebuildId,
+                            projects: reservation.reserved.length,
+                        });
+                        yield oldResources.workerPool.destroy({ requireExit: true });
+                        oldPoolDestroyed = true;
+                        if (oldResources.mlx === "owned") {
+                            yield this.mlxServerManager.stopMlxServer();
+                        }
+                        throwIfPreDropCancelled(operationSignal);
+                        yield oldResources.vectorDb.close({
+                            releaseLease: false,
+                            requireClosed: true,
+                        });
+                        oldDbClosed = true;
+                        throwIfPreDropCancelled(operationSignal);
+                        targetDb = this.createVectorDb(targetGeneration.vectorDim, exclusiveLease);
+                        (0, project_registry_1.markProjectRebuildDropping)(reservation);
+                        try {
+                            yield targetDb.drop();
+                            dropCommitted = true;
+                            conn.off("close", onClose);
+                        }
+                        catch (error) {
+                            // LanceDB does not expose a commit token. Inspect physical state:
+                            // an absent table means the destructive commit happened; an
+                            // unreadable state is treated as uncertain and therefore post-drop.
+                            try {
+                                dropCommitted = (yield targetDb.getSchemaVectorDim()) === null;
+                            }
+                            catch (_a) {
+                                dropCommitted = true;
+                            }
+                            if (dropCommitted)
+                                conn.off("close", onClose);
+                            throw error;
+                        }
+                        (0, ipc_handler_1.writeProgress)(conn, {
+                            phase: "schema",
+                            message: "creating target table",
+                        });
+                        yield targetDb.ensureTable();
+                        const physicalDim = yield targetDb.getSchemaVectorDim();
+                        if (physicalDim !== targetGeneration.vectorDim) {
+                            throw new Error(`rebuilt table dimension ${physicalDim !== null && physicalDim !== void 0 ? physicalDim : "missing"} does not match target ${targetGeneration.vectorDim}`);
+                        }
+                        if (targetConfig.embedMode === "gpu") {
+                            yield this.mlxServerManager.ensureMlxServer(targetGeneration.mlxModel);
+                        }
+                        const targetMlx = this.mlxMode(targetConfig);
+                        targetPool = this.createWorkerPool(targetGeneration, targetConfig.embedMode);
+                        this.publishResourceGeneration(targetConfig, targetGeneration, targetDb, targetPool, targetMlx);
+                        published = true;
+                        let completed = 0;
+                        const failures = [];
+                        for (const project of reservation.reserved) {
+                            if (operationSignal.aborted)
+                                throw operationSignal.reason;
                             (0, ipc_handler_1.writeProgress)(conn, {
-                                phase: "reindex",
-                                project: name,
-                                projectsDone: rebuilt,
-                                projectsTotal: projects.length,
-                                processed: info.processed,
-                                indexed: info.indexed,
-                                total: info.total,
-                                filePath: info.filePath,
+                                phase: "index",
+                                root: project.root,
+                                project: project.name,
+                                completed,
+                                totalProjects: reservation.reserved.length,
                             });
-                        });
-                        totalIndexed += result.indexed;
-                        const proj = (0, project_registry_1.getProject)(p.root);
-                        if (proj) {
-                            (0, project_registry_1.registerProject)(Object.assign(Object.assign({}, proj), { vectorDim: globalConfig.vectorDim, modelTier: globalConfig.modelTier, embedMode: globalConfig.embedMode, lastIndexed: new Date().toISOString(), chunkCount: result.indexed, status: "indexed", chunkerVersion: config_1.CONFIG.CHUNKER_VERSION }));
+                            try {
+                                const sync = yield this.reindexOneProject(project.root, { reset: true, rewatch: false }, operationSignal, (info) => (0, ipc_handler_1.writeProgress)(conn, {
+                                    phase: "index",
+                                    root: project.root,
+                                    project: project.name,
+                                    processed: info.processed,
+                                    indexed: info.indexed,
+                                    total: info.total,
+                                    filePath: info.filePath,
+                                }));
+                                if (sync.degraded) {
+                                    throw new Error(`degraded scan (${sync.failedFiles} failed files)`);
+                                }
+                                const prefix = project.root.endsWith("/")
+                                    ? project.root
+                                    : `${project.root}/`;
+                                const chunkCount = yield targetDb.countRowsForPath(prefix);
+                                (0, project_registry_1.stampProjectFullSync)({
+                                    root: project.root,
+                                    name: project.name,
+                                    generation: sync.generation,
+                                    embedMode: sync.embedMode,
+                                    chunkCount,
+                                    chunkerVersion: config_1.CONFIG.CHUNKER_VERSION,
+                                    expectedFingerprint: targetGeneration.fingerprint,
+                                    expectedRebuildId: reservation.rebuildId,
+                                });
+                                completed++;
+                            }
+                            catch (error) {
+                                failures.push({
+                                    root: project.root,
+                                    error: error instanceof Error ? error.message : String(error),
+                                });
+                            }
                         }
-                    }));
-                    rebuilt++;
+                        yield targetDb.downgradeStoreLease();
+                        targetDb.startMaintenanceLoop((fn) => this.runSharedOperation("store-maintenance", undefined, () => fn()));
+                        const currentGeneration = (0, embedding_generation_1.resolveEmbeddingGeneration)((0, index_config_1.readGlobalConfig)());
+                        const configChanged = currentGeneration.fingerprint !== targetGeneration.fingerprint;
+                        if (failures.length === 0) {
+                            (0, project_registry_1.completeProjectRebuild)(reservation.rebuildId);
+                        }
+                        return {
+                            completed,
+                            total: reservation.reserved.length,
+                            failures,
+                            configChanged,
+                            generation: targetGeneration.fingerprint,
+                        };
+                    }
+                    catch (error) {
+                        if (!dropCommitted) {
+                            this.ready = false;
+                            this.resources = null;
+                            let recoveryError;
+                            yield (targetPool === null || targetPool === void 0 ? void 0 : targetPool.destroy({ requireExit: true }).catch((cause) => {
+                                recoveryError !== null && recoveryError !== void 0 ? recoveryError : (recoveryError = cause);
+                            }));
+                            if (targetDb) {
+                                yield targetDb
+                                    .close({ releaseLease: false, requireClosed: true })
+                                    .catch((cause) => {
+                                    recoveryError !== null && recoveryError !== void 0 ? recoveryError : (recoveryError = cause);
+                                });
+                            }
+                            try {
+                                (0, project_registry_1.restoreProjectsAfterRebuild)(reservation);
+                            }
+                            catch (cause) {
+                                recoveryError !== null && recoveryError !== void 0 ? recoveryError : (recoveryError = cause);
+                            }
+                            if (!recoveryError && !oldPoolDestroyed) {
+                                try {
+                                    yield oldResources.vectorDb.downgradeStoreLease();
+                                    oldResources.vectorDb.resumeMaintenanceLoop();
+                                    this.resources = oldResources;
+                                    this.activeConfig = oldResources.config;
+                                    this.activeGeneration = oldResources.embedding;
+                                    this.vectorDb = oldResources.vectorDb;
+                                    this.workerPool = oldResources.workerPool;
+                                    this.ready = true;
+                                }
+                                catch (cause) {
+                                    recoveryError = cause;
+                                }
+                            }
+                            else if (!recoveryError) {
+                                let restoredDb = null;
+                                let restoredPool = null;
+                                try {
+                                    restoredDb = oldDbClosed
+                                        ? this.createVectorDb(oldResources.embedding.vectorDim, exclusiveLease)
+                                        : oldResources.vectorDb;
+                                    if (oldResources.config.embedMode === "gpu" &&
+                                        oldResources.mlx === "owned") {
+                                        yield this.mlxServerManager.ensureMlxServer(oldResources.embedding.mlxModel);
+                                    }
+                                    restoredPool = this.createWorkerPool(oldResources.embedding, oldResources.config.embedMode);
+                                    yield restoredDb.downgradeStoreLease();
+                                    restoredDb.startMaintenanceLoop((fn) => this.runSharedOperation("store-maintenance", undefined, () => fn()));
+                                    this.publishResourceGeneration(oldResources.config, oldResources.embedding, restoredDb, restoredPool, this.mlxMode(oldResources.config));
+                                    this.ready = true;
+                                }
+                                catch (cause) {
+                                    recoveryError = cause;
+                                    yield (restoredPool === null || restoredPool === void 0 ? void 0 : restoredPool.destroy({ requireExit: true }).catch(() => { }));
+                                    if (restoredDb) {
+                                        yield restoredDb.close().catch(() => { });
+                                    }
+                                    else {
+                                        yield exclusiveLease.release().catch(() => { });
+                                    }
+                                }
+                            }
+                            if (recoveryError) {
+                                if (!oldPoolDestroyed) {
+                                    yield oldResources.workerPool
+                                        .destroy({ requireExit: true })
+                                        .catch((cause) => {
+                                        recoveryError = new Error(`Pre-drop rebuild pool cleanup failed: ${String(recoveryError)}; ${String(cause)}`);
+                                    });
+                                    oldPoolDestroyed = true;
+                                }
+                                if (!oldDbClosed) {
+                                    yield oldResources.vectorDb.close().catch((cause) => {
+                                        recoveryError = new Error(`Pre-drop rebuild DB cleanup failed: ${String(recoveryError)}; ${String(cause)}`);
+                                    });
+                                    oldDbClosed = true;
+                                }
+                                yield exclusiveLease.release().catch((cause) => {
+                                    recoveryError = new Error(`Pre-drop rebuild cleanup failed: ${String(recoveryError)}; ${String(cause)}`);
+                                });
+                                this.resources = null;
+                                this.vectorDb = null;
+                                this.workerPool = null;
+                                this.ready = false;
+                                throw new Error(`Pre-drop rebuild recovery failed: ${String(error)}; ${String(recoveryError)}`);
+                            }
+                        }
+                        else {
+                            this.ready = false;
+                            this.resources = null;
+                            this.activeConfig = targetConfig;
+                            this.activeGeneration = targetGeneration;
+                            this.vectorDb = targetDb;
+                            this.workerPool = published ? targetPool : null;
+                            if (targetDb) {
+                                yield targetDb.downgradeStoreLease().catch(() => { });
+                            }
+                            else {
+                                yield exclusiveLease.release().catch(() => { });
+                            }
+                        }
+                        throw error;
+                    }
+                }));
+                for (const root of desiredWatchRoots) {
+                    if (((_a = (0, project_registry_1.getProject)(root)) === null || _a === void 0 ? void 0 : _a.status) !== "indexed")
+                        continue;
+                    try {
+                        yield this.watcherManager.watchProject(root, { catchup: false });
+                    }
+                    catch (error) {
+                        result.failures.push({
+                            root,
+                            error: `watch restore failed: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                    }
                 }
-                stopHeartbeat();
-                (0, ipc_handler_1.writeDone)(conn, {
-                    ok: true,
-                    projects: rebuilt,
-                    projectsTotal: projects.length,
-                    indexed: totalIndexed,
-                });
+                watchersRestored = true;
+                try {
+                    yield this.watcherManager.catchupAll(desiredWatchRoots);
+                }
+                catch (error) {
+                    result.failures.push({
+                        root: "*",
+                        error: `watch catchup failed: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                }
+                (0, ipc_handler_1.writeDone)(conn, Object.assign(Object.assign({ ok: result.failures.length === 0 }, result), (result.configChanged
+                    ? {
+                        warning: "configured embedding changed during rebuild; another rebuild is required",
+                    }
+                    : {})));
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error("[daemon] repairRebuild failed:", msg);
-                stopHeartbeat();
-                (0, ipc_handler_1.writeDone)(conn, {
-                    ok: false,
-                    error: msg,
-                    projects: rebuilt,
-                    indexed: totalIndexed,
-                });
+            catch (error) {
+                let reportedError = error;
+                if (!dropCommitted && !watchersRestored && this.ready && this.resources) {
+                    try {
+                        yield this.watcherManager.resumeAll(desiredWatchRoots, {
+                            catchup: false,
+                        });
+                        watchersRestored = true;
+                        yield this.watcherManager.catchupAll(desiredWatchRoots);
+                    }
+                    catch (watchError) {
+                        this.ready = false;
+                        this.resources = null;
+                        reportedError = new Error(`Pre-drop rebuild watcher restoration failed: ${String(error)}; ${String(watchError)}`);
+                    }
+                }
+                const details = reportedError instanceof store_lease_1.StoreLeaseTimeoutError
+                    ? { blockers: reportedError.blockers }
+                    : {};
+                (0, ipc_handler_1.writeDone)(conn, Object.assign({ ok: false, error: reportedError instanceof Error
+                        ? reportedError.message
+                        : String(reportedError), degraded: dropCommitted }, details));
             }
             finally {
+                conn.off("close", onClose);
                 stopHeartbeat();
-                this.shutdownAbortControllers.delete(ac);
-                (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
+                if (!this.ready) {
+                    setImmediate(() => void this.shutdown());
+                }
             }
         });
     }
     removeProject(root, conn) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
-                if (!this.vectorDb || !this.metaCache) {
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
-                    return;
-                }
-                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
-                try {
-                    yield this.unwatchProject(root);
-                    const rootPrefix = root.endsWith("/") ? root : `${root}/`;
-                    yield this.vectorDb.deletePathsWithPrefix(rootPrefix);
-                    const keys = yield this.metaCache.getKeysWithPrefix(rootPrefix);
-                    for (const key of keys) {
-                        this.metaCache.delete(key);
+            const ac = new AbortController();
+            const onClose = () => ac.abort();
+            conn.once("close", onClose);
+            this.shutdownAbortControllers.add(ac);
+            try {
+                yield this.withProjectLock(root, ac.signal, () => this.runSharedOperation("remove-project", ac.signal, () => __awaiter(this, void 0, void 0, function* () {
+                    if (!this.vectorDb || !this.metaCache) {
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: false,
+                            error: "daemon resources not ready",
+                        });
+                        return;
                     }
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, { ok: true });
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`[daemon] removeProject failed for ${path.basename(root)}:`, msg);
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
-                }
-                finally {
-                    stopHeartbeat();
-                }
-            }));
+                    const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
+                    try {
+                        yield this.unwatchProjectWithinOperation(root);
+                        const rootPrefix = root.endsWith("/") ? root : `${root}/`;
+                        yield this.vectorDb.deletePathsWithPrefix(rootPrefix);
+                        const keys = yield this.metaCache.getKeysWithPrefix(rootPrefix);
+                        for (const key of keys)
+                            this.metaCache.delete(key);
+                        (0, ipc_handler_1.writeDone)(conn, { ok: true });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[daemon] removeProject failed for ${path.basename(root)}:`, msg);
+                        (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
+                    }
+                    finally {
+                        stopHeartbeat();
+                    }
+                })));
+            }
+            finally {
+                conn.off("close", onClose);
+                this.shutdownAbortControllers.delete(ac);
+            }
         });
     }
     summarizeProject(root, conn, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                if (!this.vectorDb) {
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
-                    return;
-                }
-                const rootPrefix = (_a = opts.pathPrefix) !== null && _a !== void 0 ? _a : (root.endsWith("/") ? root : `${root}/`);
-                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
-                let lastProgressTime = 0;
+            const ac = new AbortController();
+            const onClose = () => ac.abort();
+            conn.once("close", onClose);
+            this.shutdownAbortControllers.add(ac);
+            try {
+                yield this.withProjectLock(root, ac.signal, () => this.runSharedOperation("summarize-project", ac.signal, () => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (!this.vectorDb) {
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: false,
+                            error: "daemon resources not ready",
+                        });
+                        return;
+                    }
+                    const rootPrefix = (_a = opts.pathPrefix) !== null && _a !== void 0 ? _a : (root.endsWith("/") ? root : `${root}/`);
+                    const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
+                    let lastProgressTime = 0;
+                    try {
+                        const result = yield (0, syncer_1.generateSummaries)(this.vectorDb, rootPrefix, (done, total) => {
+                            this.resetActivity();
+                            const now = Date.now();
+                            if (now - lastProgressTime < 100)
+                                return;
+                            lastProgressTime = now;
+                            (0, ipc_handler_1.writeProgress)(conn, { summarized: done, total });
+                        }, opts.limit);
+                        (0, ipc_handler_1.writeDone)(conn, {
+                            ok: true,
+                            summarized: result.summarized,
+                            remaining: result.remaining,
+                        });
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[daemon] summarizeProject failed for ${path.basename(root)}:`, msg);
+                        (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
+                    }
+                    finally {
+                        stopHeartbeat();
+                    }
+                })));
+            }
+            finally {
+                conn.off("close", onClose);
+                this.shutdownAbortControllers.delete(ac);
+            }
+        });
+    }
+    // --- LLM server management ---
+    llmStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.runSharedOperation("llm-start", undefined, () => __awaiter(this, void 0, void 0, function* () {
+                if (!this.llmServer)
+                    return { ok: false, error: "daemon not initialized" };
                 try {
-                    const result = yield (0, syncer_1.generateSummaries)(this.vectorDb, rootPrefix, (done, total) => {
-                        this.resetActivity();
-                        const now = Date.now();
-                        if (now - lastProgressTime < 100)
-                            return;
-                        lastProgressTime = now;
-                        (0, ipc_handler_1.writeProgress)(conn, { summarized: done, total });
-                    }, opts.limit);
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, {
-                        ok: true,
-                        summarized: result.summarized,
-                        remaining: result.remaining,
-                    });
+                    yield this.llmServer.start();
+                    this.resetActivity();
+                    return Object.assign({ ok: true }, this.llmServer.getStatus());
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
-                    console.error(`[daemon] summarizeProject failed for ${path.basename(root)}:`, msg);
-                    stopHeartbeat();
-                    (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
-                }
-                finally {
-                    stopHeartbeat();
+                    return { ok: false, error: msg };
                 }
             }));
         });
     }
-    // --- LLM server management ---
-    llmStart() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.llmServer)
-                return { ok: false, error: "daemon not initialized" };
-            try {
-                yield this.llmServer.start();
-                this.resetActivity();
-                return Object.assign({ ok: true }, this.llmServer.getStatus());
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { ok: false, error: msg };
-            }
-        });
-    }
     llmStop() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.llmServer)
-                return { ok: false, error: "daemon not initialized" };
-            try {
-                yield this.llmServer.stop();
-                return { ok: true };
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                return { ok: false, error: msg };
-            }
+            return this.runSharedOperation("llm-stop", undefined, () => __awaiter(this, void 0, void 0, function* () {
+                if (!this.llmServer)
+                    return { ok: false, error: "daemon not initialized" };
+                try {
+                    yield this.llmServer.stop();
+                    return { ok: true };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { ok: false, error: msg };
+                }
+            }));
         });
     }
     llmStatus() {
@@ -910,20 +1585,22 @@ class Daemon {
     }
     reviewCommit(root, commitRef) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.resetActivity();
-            try {
-                if (!this.llmServer) {
-                    console.log("[review] daemon not initialized, skipping");
-                    return;
+            return this.runSharedOperation("review", undefined, () => __awaiter(this, void 0, void 0, function* () {
+                this.resetActivity();
+                try {
+                    if (!this.llmServer) {
+                        console.log("[review] daemon not initialized, skipping");
+                        return;
+                    }
+                    yield this.llmServer.ensure();
+                    const { reviewCommit } = yield Promise.resolve().then(() => __importStar(require("../llm/review")));
+                    const result = yield reviewCommit({ commitRef, projectRoot: root });
+                    console.log(`[review] ${result.commit} — ${result.findingCount} finding(s) in ${result.duration}s`);
                 }
-                yield this.llmServer.ensure();
-                const { reviewCommit } = yield Promise.resolve().then(() => __importStar(require("../llm/review")));
-                const result = yield reviewCommit({ commitRef, projectRoot: root });
-                console.log(`[review] ${result.commit} — ${result.findingCount} finding(s) in ${result.duration}s`);
-            }
-            catch (err) {
-                console.error(`[review] failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
+                catch (err) {
+                    console.error(`[review] failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }));
         });
     }
     /**
@@ -945,7 +1622,7 @@ class Daemon {
         // Defer while busy; we'll re-check next tick.
         if ((_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.isMaintenanceActive())
             return;
-        if (this.projectLocks.size > 0)
+        if (this.projectMutex.pending > 0 || this.operations.activeCount > 0)
             return;
         const reason = ageExceeded
             ? `age ${(ageMs / 3600000).toFixed(1)}h > ${(MAX_LIFETIME_MS / 3600000).toFixed(1)}h`
@@ -954,22 +1631,43 @@ class Daemon {
         this.recycling = true;
         void this.shutdown({ relaunch: true }).finally(() => process.exit(0));
     }
-    shutdown() {
-        return __awaiter(this, arguments, void 0, function* (opts = {}) {
+    shutdown(opts = {}) {
+        if (!this.shutdownPromise) {
+            this.shutdownPromise = this.performShutdown(opts);
+        }
+        return this.shutdownPromise;
+    }
+    performShutdown(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
-            if (this.shuttingDown)
-                return;
             this.shuttingDown = true;
+            this.ready = false;
+            const strictResourceShutdown = this.hasUnfinishedRebuild();
             console.log("[daemon] Shutting down...");
             // Announce graceful shutdown BEFORE dropping the liveness markers below, so a
             // successor spawned during the (possibly long) drain sees the draining marker
             // and defers instead of SIGKILLing us mid-cleanup.
             (0, daemon_client_1.writeDrainingMarker)(process.pid);
-            // Drop external liveness markers FIRST so the next daemon start isn't
-            // fooled by leftover state if the long cleanup below is interrupted
-            // (uncaught exception, second SIGTERM, OOM kill mid-shutdown). The
-            // fresh-lock check in isDaemonHeartbeatFresh keyed on these — orphans
-            // here used to cause silent no-op spawns for up to 150s.
+            // Stop accepting new IPC before draining admitted operations. Existing
+            // sockets are destroyed below so their close handlers cancel queued work.
+            const server = this.server;
+            this.server = null;
+            const serverClosed = new Promise((resolve) => {
+                if (!(server === null || server === void 0 ? void 0 : server.listening)) {
+                    resolve();
+                    return;
+                }
+                server.close(() => resolve());
+            });
+            for (const connection of this.connections)
+                connection.end();
+            const forceCloseConnections = setTimeout(() => {
+                for (const connection of this.connections)
+                    connection.destroy();
+            }, 1000);
+            forceCloseConnections.unref();
+            // Drop external liveness markers now so interrupted cleanup cannot leave a
+            // fresh-looking daemon that silently blocks its successor.
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
@@ -981,44 +1679,60 @@ class Daemon {
             if (this.releaseLock) {
                 const release = this.releaseLock;
                 this.releaseLock = null;
-                release().catch(() => { });
+                try {
+                    yield release();
+                }
+                catch (_g) { }
             }
             if (this.heartbeatInterval)
                 clearInterval(this.heartbeatInterval);
             if (this.idleInterval)
                 clearInterval(this.idleInterval);
-            // Abort in-flight index/add operations so they exit promptly
-            for (const ac of this.shutdownAbortControllers) {
-                ac.abort();
-            }
-            // Wait for in-flight project operations to finish (they check shuttingDown/signal)
-            const pendingLocks = [...this.projectLocks.values()];
-            if (pendingLocks.length > 0) {
-                console.log(`[daemon] Waiting for ${pendingLocks.length} in-flight operation(s)...`);
-                yield Promise.allSettled(pendingLocks);
+            for (const timer of this.pendingIndexRetryTimers.values()) {
+                clearTimeout(timer);
             }
-            // Close all processors
-            for (const processor of this.processors.values()) {
-                yield processor.close();
+            this.pendingIndexRetryTimers.clear();
+            this.pendingIndexRetryCounts.clear();
+            // Abort explicit operation controllers, close coordinator admission, and
+            // reject queued project waiters. Start these drains before watcher teardown
+            // so no timer or socket can admit replacement work.
+            for (const ac of this.shutdownAbortControllers) {
+                ac.abort(new operation_coordinator_1.OperationClosedError());
             }
+            const operationDrain = this.operations.close();
+            const projectDrain = this.projectMutex.close();
+            // Abort catchup/recovery and remove each processor before worker teardown.
+            yield this.watcherManager.quiesceAll();
+            yield Promise.all([operationDrain, projectDrain]);
             // Stop LLM server if running
             try {
                 yield ((_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.stop());
             }
-            catch (_g) { }
-            // Stop MLX embed server if we started it
-            this.mlxServerManager.stopMlxServer();
+            catch (_h) { }
             // Destroy worker pool to prevent orphaned child processes
+            if (this.workerPool) {
+                if (strictResourceShutdown) {
+                    yield this.workerPool.destroy({
+                        requireExit: true,
+                    });
+                }
+                else {
+                    try {
+                        yield this.workerPool.destroy();
+                    }
+                    catch (_j) { }
+                }
+                this.workerPool = null;
+                this.resources = null;
+            }
             if ((0, pool_1.isWorkerPoolInitialized)()) {
                 try {
                     yield (0, pool_1.destroyWorkerPool)();
                 }
-                catch (_h) { }
+                catch (_k) { }
             }
-            // 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();
+            // Stop MLX embed server only after worker requests have drained.
+            yield this.mlxServerManager.stopMlxServer();
             // Unregister all
             for (const root of this.processors.keys()) {
                 (0, watcher_store_1.unregisterWatcherByRoot)(root);
@@ -1027,19 +1741,27 @@ class Daemon {
             this.processors.clear();
             // Close shared resources
             try {
-                yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
+                yield ((_b = this.metaCache) === null || _b === void 0 ? void 0 : _b.close());
             }
-            catch (_j) { }
-            try {
-                yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
+            catch (_l) { }
+            if (strictResourceShutdown) {
+                yield ((_c = this.vectorDb) === null || _c === void 0 ? void 0 : _c.close({ requireClosed: true }));
+            }
+            else {
+                try {
+                    yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
+                }
+                catch (_m) { }
             }
-            catch (_k) { }
+            yield serverClosed;
+            clearTimeout(forceCloseConnections);
+            this.connections.clear();
             // 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
             // without contending with this exiting process.
             if (opts.relaunch) {
-                const pid = (0, daemon_launcher_1.spawnDaemon)();
+                const pid = yield (0, daemon_launcher_1.spawnDaemon)();
                 console.log(`[daemon] Spawned successor daemon${pid ? ` (PID: ${pid})` : " (spawn failed)"}`);
             }
             // Cleanly drained — drop the marker so a later start doesn't defer to a