grepmax 0.19.0 → 0.21.0

package/dist/commands/status.js

@@ -121,7 +121,7 @@ Examples:
             const rows = yield table
                 .query()
                 .select(["id"])
-                .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                .where((0, filter_builder_1.pathStartsWith)(prefix))
                 .toArray();
             chunkCounts.set(project.root, rows.length);
         }

package/dist/commands/symbols.js

@@ -86,7 +86,7 @@ function collectSymbols(options) {
                 const absPrefix = path.isAbsolute(options.pathPrefix)
                     ? options.pathPrefix
                     : path.resolve(options.projectRoot, options.pathPrefix);
-                query = query.where(`path LIKE '${(0, filter_builder_1.escapeSqlString)((0, filter_builder_1.normalizePath)(absPrefix))}%'`);
+                query = query.where((0, filter_builder_1.pathStartsWith)((0, filter_builder_1.normalizePath)(absPrefix)));
             }
             const rows = yield query.toArray();
             const map = new Map();

package/dist/commands/watch.js

@@ -81,7 +81,7 @@ exports.watch = new commander_1.Command("watch")
             // Skip spawn if daemon already running at the same version.
             // If version mismatches (e.g. after npm install -g), shut down the old
             // daemon so we can start a fresh one with the new code.
-            const { isDaemonRunning, isDaemonHeartbeatFresh, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+            const { isDaemonRunning, isDaemonHeartbeatFresh, sendDaemonCommand, readDaemonPid, waitForProcessExit, } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
             if (yield isDaemonRunning()) {
                 const cliVersion = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), "utf-8")).version;
                 const resp = yield sendDaemonCommand({ cmd: "ping" });
@@ -89,6 +89,12 @@ exports.watch = new commander_1.Command("watch")
                     process.exit(0);
                 }
                 console.log(`Daemon version mismatch (${resp.version} → ${cliVersion}), restarting...`);
+                // Capture the old PID before shutdown removes the PID file, so we
+                // can wait for the process to fully EXIT rather than guessing with a
+                // fixed sleep. Spawning the successor while the old daemon is still
+                // draining lets the successor's killStaleProcesses() classify it as
+                // stale and SIGKILL it mid-cleanup.
+                const oldPid = readDaemonPid();
                 yield sendDaemonCommand({
                     cmd: "shutdown",
                     reason: "version-mismatch",
@@ -97,8 +103,16 @@ exports.watch = new commander_1.Command("watch")
                     from_version: cliVersion,
                     from_argv: process.argv.slice(0, 4),
                 });
-                // Brief wait for old daemon to release socket/lock
-                yield new Promise((r) => setTimeout(r, 2000));
+                if (oldPid) {
+                    const exited = yield waitForProcessExit(oldPid, 20000);
+                    if (!exited) {
+                        console.log(`Old daemon (PID ${oldPid}) still draining after 20s — starting anyway ` +
+                            `(its draining marker keeps the successor from killing it mid-cleanup)`);
+                    }
+                }
+                else {
+                    yield new Promise((r) => setTimeout(r, 2000));
+                }
             }
             else if (isDaemonHeartbeatFresh()) {
                 // Ping failed but daemon.lock mtime is fresh — another daemon is
@@ -131,6 +145,13 @@ exports.watch = new commander_1.Command("watch")
                 process.exit(0);
             }
             console.error("[daemon] Failed to start:", err);
+            // Tear down any half-opened state — the listening socket, PID, and
+            // lock — so we don't leave a zombie that answers pings but has no
+            // resources. The socket also keeps the event loop alive otherwise.
+            try {
+                yield daemon.shutdown();
+            }
+            catch (_c) { }
             process.exitCode = 1;
             return;
         }
@@ -201,7 +222,7 @@ exports.watch = new commander_1.Command("watch")
     const indexed = yield table
         .query()
         .select(["id"])
-        .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+        .where((0, filter_builder_1.pathStartsWith)(prefix))
         .limit(1)
         .toArray();
     if (indexed.length === 0) {

package/dist/config.js

@@ -33,9 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INDEXABLE_EXTENSIONS = exports.FRAGMENT_COMPACT_THRESHOLD = exports.DISK_LOW_BYTES = exports.DISK_CRITICAL_BYTES = exports.MAX_FILE_SIZE_BYTES = exports.PATHS = exports.MAX_WORKER_MEMORY_MB = exports.WORKER_BOOT_TIMEOUT_MS = exports.WORKER_TIMEOUT_MS = exports.CHUNKER_VERSION_HISTORY = exports.CONFIG = exports.MODEL_IDS = exports.DEFAULT_MODEL_TIER = exports.MODEL_TIERS = void 0;
+exports.INDEXABLE_EXTENSIONS = exports.FRAGMENT_COMPACT_THRESHOLD = exports.DISK_LOW_BYTES = exports.DISK_CRITICAL_BYTES = exports.MAX_FILE_SIZE_BYTES = exports.PATHS = exports.MAX_WORKER_MEMORY_MB = exports.WORKER_BOOT_TIMEOUT_MS = exports.WORKER_TIMEOUT_MS = exports.REBUILD_COMMAND = exports.CHUNKER_VERSION_HISTORY = exports.CONFIG = exports.MODEL_IDS = exports.DEFAULT_MODEL_TIER = exports.MODEL_TIERS = void 0;
 exports.describeChunkerGap = describeChunkerGap;
 exports.describeEmbeddingGap = describeEmbeddingGap;
+exports.describeSchemaDimGap = describeSchemaDimGap;
+exports.schemaDimAgentRow = schemaDimAgentRow;
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 exports.MODEL_TIERS = {
@@ -157,6 +159,43 @@ function describeEmbeddingGap(stored, current) {
         severity: dimChanged ? "breaking" : "additive",
     };
 }
+/**
+ * The single sanctioned recovery for a physical table-width mismatch. The shared
+ * `chunks` table is fixed-width at creation, so a tier/dim change strands it at
+ * the old width and every write throws. A per-project `gmax index --reset` only
+ * deletes rows — it can't change the shared table's width — so the real fix is a
+ * global drop-and-rebuild. doctor, the insertBatch failure, and the staleness
+ * hint all point here so the guidance never contradicts itself.
+ */
+exports.REBUILD_COMMAND = "gmax repair --rebuild";
+/**
+ * Describe the gap between the LanceDB table's PHYSICAL `vector` width and the
+ * width the current global config would produce, or null when they agree (or no
+ * table exists yet). This is distinct from {@link describeEmbeddingGap}: that one
+ * compares the project REGISTRY's recorded `{modelTier, vectorDim}` to config
+ * (logical drift, fixable per project), while this compares the actual on-disk
+ * table schema to config (physical drift — every write throws until a global
+ * rebuild). A table can match the registry yet still be physically stranded, so
+ * doctor reports both independently.
+ */
+function describeSchemaDimGap(tableDim, configDim) {
+    if (tableDim == null)
+        return null; // no table on disk yet — nothing to compare
+    if (tableDim === configDim)
+        return null;
+    return { tableDim, configDim };
+}
+/** Stable, tab-delimited doctor `--agent` row for a physical schema-dim
+ * mismatch. Kept here (pure) so the wire format is testable without running the
+ * full doctor command. */
+function schemaDimAgentRow(gap) {
+    return [
+        "schema_dim_mismatch",
+        `table_dim=${gap.tableDim}`,
+        `current_dim=${gap.configDim}`,
+        `fix=${exports.REBUILD_COMMAND}`,
+    ].join("\t");
+}
 exports.WORKER_TIMEOUT_MS = Number.parseInt(process.env.GMAX_WORKER_TIMEOUT_MS || "60000", 10);
 exports.WORKER_BOOT_TIMEOUT_MS = Number.parseInt(process.env.GMAX_WORKER_BOOT_TIMEOUT_MS || "300000", 10);
 exports.MAX_WORKER_MEMORY_MB = (() => {
@@ -177,6 +216,11 @@ exports.PATHS = {
     daemonSocket: path.join(GLOBAL_ROOT, "daemon.sock"),
     daemonPidFile: path.join(GLOBAL_ROOT, "daemon.pid"),
     daemonLockFile: path.join(GLOBAL_ROOT, "daemon.lock"),
+    // Written by a daemon while it is gracefully shutting down (draining workers,
+    // closing LanceDB). A successor's killStaleProcesses() respects this so it
+    // never SIGKILLs a peer mid-cleanup once the peer has already dropped its
+    // socket/PID/lock liveness markers.
+    daemonDrainingFile: path.join(GLOBAL_ROOT, "daemon.draining"),
     // Centralized index storage — one database for all indexed directories
     lancedbDir: path.join(GLOBAL_ROOT, "lancedb"),
     cacheDir: path.join(GLOBAL_ROOT, "cache"),

package/dist/index.js

@@ -64,6 +64,7 @@ const project_1 = require("./commands/project");
 const recent_1 = require("./commands/recent");
 const related_1 = require("./commands/related");
 const remove_1 = require("./commands/remove");
+const repair_1 = require("./commands/repair");
 const review_1 = require("./commands/review");
 const search_1 = require("./commands/search");
 const serve_1 = require("./commands/serve");
@@ -141,6 +142,7 @@ commander_1.program.addCommand(review_1.review);
 commander_1.program.addCommand(setup_1.setup);
 commander_1.program.addCommand(config_1.config);
 commander_1.program.addCommand(doctor_1.doctor);
+commander_1.program.addCommand(repair_1.repair);
 // Plugins
 commander_1.program.addCommand(plugin_1.plugin);
 // Legacy plugin installers (hidden — use `gmax plugin` instead)

package/dist/lib/daemon/daemon.js

@@ -56,6 +56,7 @@ const syncer_1 = require("../index/syncer");
 const server_1 = require("../llm/server");
 const meta_cache_1 = require("../store/meta-cache");
 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 log_rotate_1 = require("../utils/log-rotate");
 const logger_1 = require("../utils/logger");
@@ -116,6 +117,10 @@ class Daemon {
         this.heartbeatTick = 0;
         this.shuttingDown = false;
         this.recycling = false;
+        // False until LanceDB + MetaCache are open. The socket starts listening early
+        // (so liveness probes succeed during slow init), so commands that need those
+        // resources must be gated on this to avoid hitting null stores mid-startup.
+        this.ready = false;
         this.processManager = new process_manager_1.ProcessManager({
             getShuttingDown: () => this.shuttingDown,
         });
@@ -253,6 +258,8 @@ class Daemon {
                 this.vectorDb.startMaintenanceLoop();
                 console.log("[daemon] Opening MetaCache:", config_1.PATHS.lmdbPath);
                 this.metaCache = new meta_cache_1.MetaCache(config_1.PATHS.lmdbPath);
+                // Resources are open — only now may resource-dependent IPC commands run.
+                this.ready = true;
             }
             catch (err) {
                 console.error("[daemon] Failed to open shared resources:", err);
@@ -499,6 +506,10 @@ class Daemon {
     uptime() {
         return Math.floor((Date.now() - this.startTime) / 1000);
     }
+    /** True once shared resources (LanceDB + MetaCache) are open. */
+    isReady() {
+        return this.ready;
+    }
     getDiskPressure() {
         var _a, _b;
         return (_b = (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.diskPressure) !== null && _b !== void 0 ? _b : "unknown";
@@ -590,6 +601,66 @@ class Daemon {
             }));
         });
     }
+    /**
+     * Core full-(re)index of one project: quiesce its batch processor + watcher,
+     * run initialSync, then re-watch in the finally. Shared by indexProject (one
+     * project per IPC connection) and repairRebuild (all projects after a global
+     * table drop). The caller owns the project lock, the maintenance pause, the
+     * heartbeat, and the AbortController; this method owns the watcher handoff and
+     * the indexProgress bookkeeping (so concurrent searches get a partial-result
+     * footer while it runs — Phase 6).
+     */
+    reindexOneProject(root, opts, signal, onProgress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            }
+            // 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 });
+            try {
+                return yield (0, syncer_1.initialSync)({
+                    projectRoot: root,
+                    reset: opts.reset,
+                    dryRun: opts.dryRun,
+                    vectorDb: this.vectorDb,
+                    metaCache: this.metaCache,
+                    signal,
+                    onProgress: (info) => {
+                        this.resetActivity();
+                        this.indexProgress.set(root, {
+                            processed: info.processed,
+                            total: info.total,
+                        });
+                        onProgress(info);
+                    },
+                });
+            }
+            finally {
+                this.indexProgress.delete(root);
+                // Re-enable watcher (skip if shutting down)
+                if (!this.shuttingDown) {
+                    try {
+                        yield this.watchProject(root);
+                    }
+                    catch (err) {
+                        console.error(`[daemon] Failed to re-watch ${path.basename(root)}:`, err);
+                    }
+                }
+            }
+        });
+    }
     indexProject(root, conn, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
@@ -598,51 +669,24 @@ class Daemon {
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
                     return;
                 }
-                // 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);
-                }
                 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;
-                // 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 });
                 try {
-                    const result = yield (0, syncer_1.initialSync)({
-                        projectRoot: root,
-                        reset: opts.reset,
-                        dryRun: opts.dryRun,
-                        vectorDb: this.vectorDb,
-                        metaCache: this.metaCache,
-                        signal: ac.signal,
-                        onProgress: (info) => {
-                            this.resetActivity();
-                            this.indexProgress.set(root, {
-                                processed: info.processed,
-                                total: info.total,
-                            });
-                            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 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,
+                        });
                     });
                     stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, {
@@ -661,22 +705,100 @@ class Daemon {
                 }
                 finally {
                     stopHeartbeat();
-                    this.indexProgress.delete(root);
                     this.shutdownAbortControllers.delete(ac);
                     (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
-                    // Re-enable watcher (skip if shutting down)
-                    if (!this.shuttingDown) {
-                        try {
-                            yield this.watchProject(root);
-                        }
-                        catch (err) {
-                            console.error(`[daemon] Failed to re-watch ${path.basename(root)}:`, err);
-                        }
-                    }
                 }
             }));
         });
     }
+    /**
+     * Global recovery for a physical table-width mismatch (the chosen "global
+     * rebuild" strategy): drop the shared `chunks` table and re-index every
+     * registered project at the configured dim. The table is fixed-width at
+     * creation, so this is the only way to move it from e.g. 384d to 768d after a
+     * tier change. Streams per-project progress over `conn`. Each project is
+     * reindexed under its own lock with `reset: true`, which also clears that
+     * project's stale MetaCache entries so everything re-embeds into the freshly
+     * recreated (lazily, at config width) table.
+     */
+    repairRebuild(conn) {
+        return __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);
+            // 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;
+            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;
+                            (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,
+                            });
+                        });
+                        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 }));
+                        }
+                    }));
+                    rebuilt++;
+                }
+                stopHeartbeat();
+                (0, ipc_handler_1.writeDone)(conn, {
+                    ok: true,
+                    projects: rebuilt,
+                    projectsTotal: projects.length,
+                    indexed: totalIndexed,
+                });
+            }
+            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,
+                });
+            }
+            finally {
+                stopHeartbeat();
+                this.shutdownAbortControllers.delete(ac);
+                (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
+            }
+        });
+    }
     removeProject(root, conn) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.withProjectLock(root, () => __awaiter(this, void 0, void 0, function* () {
@@ -839,6 +961,10 @@ class Daemon {
                 return;
             this.shuttingDown = true;
             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
@@ -916,6 +1042,9 @@ class Daemon {
                 const pid = (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
+            // process that's already gone (it self-expires after DRAIN_GRACE_MS anyway).
+            (0, daemon_client_1.clearDrainingMarker)();
             console.log("[daemon] Shutdown complete");
         });
     }

package/dist/lib/daemon/ipc-handler.js

@@ -105,6 +105,12 @@ function handleCommand(daemon, cmd, conn) {
         var _a, _b, _c, _d, _e;
         try {
             (0, logger_1.debug)("daemon", `ipc cmd=${cmd.cmd}${cmd.root ? ` root=${cmd.root}` : ""}`);
+            // The socket listens before LanceDB/MetaCache are open so liveness probes
+            // succeed during slow startup. Gate resource-dependent commands until those
+            // stores exist; ping/shutdown must always work (probes + restart).
+            if (cmd.cmd !== "ping" && cmd.cmd !== "shutdown" && !daemon.isReady()) {
+                return { ok: false, error: "daemon initializing" };
+            }
             switch (cmd.cmd) {
                 case "ping":
                     return {
@@ -222,6 +228,12 @@ function handleCommand(daemon, cmd, conn) {
                     daemon.removeProject(root, conn);
                     return null;
                 }
+                case "repair": {
+                    // Global drop-and-rebuild recovery for a physical table-width mismatch.
+                    // Streams per-project progress; daemon manages the connection.
+                    daemon.repairRebuild(conn);
+                    return null;
+                }
                 case "summarize": {
                     const root = String(cmd.root || "");
                     if (!root)

package/dist/lib/daemon/process-manager.js

@@ -89,8 +89,19 @@ class ProcessManager {
                 (0, logger_1.log)("daemon", "No stale processes found");
                 return;
             }
+            // A peer that's gracefully shutting down has already dropped its
+            // socket/PID/lock (so the liveness probes below read "stale") yet is still
+            // mid-cleanup — destroying workers, closing LanceDB. Killing it now corrupts
+            // that teardown. Defer to its draining marker: don't kill it, and don't
+            // sweep its workers (it's reaping them itself); just take over the free lock.
+            let anyDraining = false;
             for (const pid of daemonPids) {
                 (0, logger_1.log)("daemon", `found daemon PID:${pid}, checking liveness...`);
+                if ((0, daemon_client_1.isDaemonDraining)(pid)) {
+                    anyDraining = true;
+                    (0, logger_1.log)("daemon", `daemon PID:${pid} is gracefully draining — leaving it to exit, taking over`);
+                    continue;
+                }
                 // A busy daemon (mid-index, compaction, big LMDB write) can block the
                 // event loop long enough to miss a ping. Two independent liveness
                 // probes — if either says "alive", defer to the running peer instead
@@ -109,9 +120,16 @@ class ProcessManager {
             }
             // 2. Kill orphaned workers from previous daemon instances.
             // Safe because this runs before the new daemon's worker pool is initialized.
-            for (const pid of workerPids) {
-                (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
-                yield (0, process_1.killProcess)(pid);
+            // Skipped while a peer is draining — those workers belong to it and it's
+            // tearing them down; sweeping them here would race its own cleanup.
+            if (anyDraining) {
+                (0, logger_1.log)("daemon", "skipping orphan-worker sweep — a peer is draining its own workers");
+            }
+            else {
+                for (const pid of workerPids) {
+                    (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
+                    yield (0, process_1.killProcess)(pid);
+                }
             }
             (0, logger_1.log)("daemon", `Cleaned up ${daemonPids.length} stale daemon(s), ${workerPids.length} orphaned worker(s)`);
         });

package/dist/lib/daemon/watcher-manager.js

@@ -368,12 +368,15 @@ class WatcherManager {
                     const bn = path.basename(absPath).toLowerCase();
                     if (!INDEXABLE_EXTENSIONS.has(ext) && !INDEXABLE_EXTENSIONS.has(bn))
                         continue;
-                    seenPaths.add(absPath);
                     try {
                         const stats = yield fs.promises.stat(absPath);
-                        // Skip files that are too large or empty — they'll never be indexed
+                        // Skip files that are too large or empty — they'll never be indexed.
+                        // Leave them OUT of seenPaths so a file that became empty/oversized is
+                        // treated as deleted by the purge sweep below and its now-stale chunks
+                        // are removed, rather than lingering as unsearchable-but-present rows.
                         if (stats.size === 0 || stats.size > MAX_FILE_SIZE_BYTES)
                             continue;
+                        seenPaths.add(absPath);
                         const cached = metaCache.get(absPath);
                         if (!isFileCached(cached, stats)) {
                             // Fast path: if only mtime changed but size is identical and we have a hash,
@@ -439,6 +442,19 @@ class WatcherManager {
     }
     unwatchProject(root) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Stop poll-mode timers + their FSEvents recovery probe first, so a removed
+            // project can't keep scanning until full daemon shutdown. These live
+            // independently of the processor, so clear them even on the early return.
+            const pollInterval = this.pollIntervals.get(root);
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                this.pollIntervals.delete(root);
+            }
+            const recoveryTimer = this.pollRecoveryTimers.get(root);
+            if (recoveryTimer) {
+                clearInterval(recoveryTimer);
+                this.pollRecoveryTimers.delete(root);
+            }
             const processor = this.deps.processors.get(root);
             if (!processor)
                 return;

package/dist/lib/graph/graph-builder.js

@@ -27,10 +27,10 @@ class GraphBuilder {
     scopeWhere(condition) {
         let result = condition;
         if (this.pathPrefix) {
-            result = `${result} AND path LIKE '${(0, filter_builder_1.escapeSqlString)(this.pathPrefix)}%'`;
+            result = `${result} AND ${(0, filter_builder_1.pathStartsWith)(this.pathPrefix)}`;
         }
         for (const ex of this.excludePrefixes) {
-            result = `${result} AND path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(ex)}%'`;
+            result = `${result} AND ${(0, filter_builder_1.pathNotStartsWith)(ex)}`;
         }
         return result;
     }

package/dist/lib/graph/impact.js

@@ -66,10 +66,10 @@ function expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes) {
             return symbols;
         const table = yield vectorDb.ensureTable();
         const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
-        let where = `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbols[0])}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`;
+        let where = `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbols[0])}') AND ${(0, filter_builder_1.pathStartsWith)(prefix)}`;
         for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
-            where += ` AND path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(exNorm)}%'`;
+            where += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
         }
         // Find the file that defines this symbol
         const defRows = yield table
@@ -146,10 +146,10 @@ function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, pro
         // test body's referenced_symbols ends up empty).
         const table = yield vectorDb.ensureTable();
         const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
-        let pathScope = `path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`;
+        let pathScope = (0, filter_builder_1.pathStartsWith)(prefix);
         for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
-            pathScope += ` AND path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(exNorm)}%'`;
+            pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
         }
         // Textual matching runs on the ORIGINAL targets only: matching co-defined
         // file symbols (helpers like `log`) textually drags in every test file
@@ -203,10 +203,10 @@ function walkCallers(symbol, graphBuilder, testHits, currentHop, maxDepth, visit
 function findDependents(symbols_1, vectorDb_1, projectRoot_1, excludePaths_1) {
     return __awaiter(this, arguments, void 0, function* (symbols, vectorDb, projectRoot, excludePaths, limit = 10, excludePrefixes) {
         const table = yield vectorDb.ensureTable();
-        let pathScope = `path LIKE '${(0, filter_builder_1.escapeSqlString)(projectRoot)}/%'`;
+        let pathScope = (0, filter_builder_1.pathStartsWith)(`${projectRoot}/`);
         for (const ex of excludePrefixes !== null && excludePrefixes !== void 0 ? excludePrefixes : []) {
             const exNorm = ex.endsWith("/") ? ex : `${ex}/`;
-            pathScope += ` AND path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(exNorm)}%'`;
+            pathScope += ` AND ${(0, filter_builder_1.pathNotStartsWith)(exNorm)}`;
         }
         const counts = new Map();
         for (const sym of symbols) {

package/dist/lib/index/batch-processor.js

@@ -177,8 +177,17 @@ class ProjectBatchProcessor {
                     // change or add
                     try {
                         const stats = yield fs.promises.stat(absPath);
-                        if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
+                        if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size)) {
+                            // File became non-indexable (emptied or now too large). If we
+                            // indexed it before, drop its chunks + meta so search stops
+                            // returning stale content; otherwise there's nothing to clean up.
+                            if (this.metaCache.get(absPath)) {
+                                deletes.push(absPath);
+                                metaDeletes.push(absPath);
+                                reindexed++;
+                            }
                             continue;
+                        }
                         const cached = this.metaCache.get(absPath);
                         if ((0, cache_check_1.isFileCached)(cached, stats)) {
                             continue;