grepmax 0.18.1 → 0.20.0

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

@@ -105,9 +105,20 @@ 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 { ok: true, pid: process.pid, uptime: daemon.uptime(), version: DAEMON_VERSION };
+                    return {
+                        ok: true,
+                        pid: process.pid,
+                        uptime: daemon.uptime(),
+                        version: DAEMON_VERSION,
+                    };
                 case "watch": {
                     const root = String(cmd.root || "");
                     if (!root)
@@ -135,7 +146,9 @@ function handleCommand(daemon, cmd, conn) {
                     const fromPid = (_b = cmd.from_pid) !== null && _b !== void 0 ? _b : "?";
                     const fromPpid = (_c = cmd.from_ppid) !== null && _c !== void 0 ? _c : "?";
                     const fromVer = (_d = cmd.from_version) !== null && _d !== void 0 ? _d : "?";
-                    const fromArgv = Array.isArray(cmd.from_argv) ? cmd.from_argv.join(" ") : "?";
+                    const fromArgv = Array.isArray(cmd.from_argv)
+                        ? cmd.from_argv.join(" ")
+                        : "?";
                     const fromParentCmd = (_e = cmd.from_parent_cmd) !== null && _e !== void 0 ? _e : "?";
                     console.log(`[daemon] shutdown command received via IPC: reason=${reason} from_pid=${fromPid} from_ppid=${fromPpid} from_version=${fromVer} from_argv=[${fromArgv}] from_parent_cmd=[${fromParentCmd}]`);
                     setImmediate(() => daemon.shutdown());
@@ -155,12 +168,16 @@ function handleCommand(daemon, cmd, conn) {
                     conn.on("close", onClose);
                     try {
                         const limitRaw = typeof cmd.limit === "number" ? cmd.limit : 10;
-                        const skeletonLimitRaw = typeof cmd.skeletonLimit === "number" ? cmd.skeletonLimit : undefined;
+                        const skeletonLimitRaw = typeof cmd.skeletonLimit === "number"
+                            ? cmd.skeletonLimit
+                            : undefined;
                         // Accept both the legacy single-string `exclude` and the new
                         // `excludePrefixes`/`inPrefixes` arrays (--in/--exclude on the CLI).
                         // Daemon may outlive a CLI restart, so keep both wire shapes for
                         // one release; drop the single-string form in v0.17.x.
-                        const filters = cmd.filters && typeof cmd.filters === "object" && !Array.isArray(cmd.filters)
+                        const filters = cmd.filters &&
+                            typeof cmd.filters === "object" &&
+                            !Array.isArray(cmd.filters)
                             ? cmd.filters
                             : undefined;
                         const resp = yield daemon.search({
@@ -171,7 +188,9 @@ function handleCommand(daemon, cmd, conn) {
                             pathPrefix: typeof cmd.pathPrefix === "string" ? cmd.pathPrefix : undefined,
                             rerank: cmd.rerank === true,
                             explain: cmd.explain === true,
-                            seeds: cmd.seeds && typeof cmd.seeds === "object" && !Array.isArray(cmd.seeds)
+                            seeds: cmd.seeds &&
+                                typeof cmd.seeds === "object" &&
+                                !Array.isArray(cmd.seeds)
                                 ? cmd.seeds
                                 : undefined,
                             includeSkeletons: cmd.includeSkeletons === true,

package/dist/lib/daemon/mlx-server-manager.js

@@ -69,15 +69,23 @@ class MlxServerManager {
         return __awaiter(this, void 0, void 0, function* () {
             const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
             return new Promise((resolve) => {
-                const req = http.get({ hostname: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => { res.resume(); resolve(res.statusCode === 200); });
+                const req = http.get({ hostname: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => {
+                    res.resume();
+                    resolve(res.statusCode === 200);
+                });
                 req.on("error", () => resolve(false));
-                req.on("timeout", () => { req.destroy(); resolve(false); });
+                req.on("timeout", () => {
+                    req.destroy();
+                    resolve(false);
+                });
             });
         });
     }
     getPortPid(port) {
         try {
-            const out = (0, node_child_process_1.execSync)(`lsof -ti :${port}`, { timeout: 5000 }).toString().trim();
+            const out = (0, node_child_process_1.execSync)(`lsof -ti :${port}`, { timeout: 5000 })
+                .toString()
+                .trim();
             const pid = parseInt(out.split("\n")[0], 10);
             return Number.isFinite(pid) ? pid : null;
         }

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

@@ -83,8 +83,7 @@ class ProcessManager {
     killStaleProcesses() {
         return __awaiter(this, void 0, void 0, function* () {
             // 1. Check for other daemon processes
-            const daemonPids = this.findProcessesByTitle("gmax-daemon")
-                .filter((pid) => pid !== process.pid);
+            const daemonPids = this.findProcessesByTitle("gmax-daemon").filter((pid) => pid !== process.pid);
             const workerPids = this.findProcessesByTitle("gmax-worker");
             if (daemonPids.length === 0 && workerPids.length === 0) {
                 (0, logger_1.log)("daemon", "No stale processes found");

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

@@ -50,9 +50,9 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WatcherManager = void 0;
-const watcher = __importStar(require("@parcel/watcher"));
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const watcher = __importStar(require("@parcel/watcher"));
 const batch_processor_1 = require("../index/batch-processor");
 const watcher_1 = require("../index/watcher");
 const logger_1 = require("../utils/logger");
@@ -250,7 +250,7 @@ class WatcherManager {
             return;
         }
         // Backoff: wait before re-subscribing (3s, 6s, 12s)
-        const delayMs = 3000 * Math.pow(2, fails - 1);
+        const delayMs = 3000 * Math.pow(2, (fails - 1));
         console.error(`[daemon:${name}] Recovering watcher (attempt ${fails}/${MAX_WATCHER_RETRIES}, backoff ${delayMs}ms)...`);
         setTimeout(() => {
             if (this.deps.getShuttingDown()) {
@@ -368,17 +368,20 @@ 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,
                             // just verify the hash in-process instead of sending to a worker.
-                            if (cached && cached.hash && cached.size === stats.size) {
+                            if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
                                 const { computeBufferHash } = yield Promise.resolve().then(() => __importStar(require("../utils/file-utils")));
                                 const buf = yield fs.promises.readFile(absPath);
                                 const hash = computeBufferHash(buf);
@@ -400,7 +403,7 @@ class WatcherManager {
                             // batch processor drain and compaction run between bursts.
                             if (queued % 500 === 0) {
                                 (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
-                                yield new Promise(r => setTimeout(r, 5000));
+                                yield new Promise((r) => setTimeout(r, 5000));
                             }
                         }
                         else {
@@ -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/callsites.js

@@ -110,37 +110,163 @@ function resolveCallSites(callers, targetSymbol, fileCache = new Map()) {
  */
 const BUILTIN_CALLEES = new Set([
     // Object/primitive methods
-    "toString", "valueOf", "hasOwnProperty",
+    "toString",
+    "valueOf",
+    "hasOwnProperty",
     // Array/String methods
-    "push", "pop", "shift", "unshift", "slice", "splice", "concat", "join",
-    "map", "filter", "reduce", "forEach", "find", "findIndex", "some", "every",
-    "includes", "indexOf", "lastIndexOf", "sort", "reverse", "flat", "flatMap",
-    "keys", "values", "entries", "fill",
-    "split", "trim", "trimStart", "trimEnd", "replace", "replaceAll", "match",
-    "matchAll", "test", "exec", "padStart", "padEnd", "repeat", "charAt",
-    "charCodeAt", "codePointAt", "startsWith", "endsWith", "toLowerCase",
-    "toUpperCase", "substring", "substr", "localeCompare", "normalize",
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "slice",
+    "splice",
+    "concat",
+    "join",
+    "map",
+    "filter",
+    "reduce",
+    "forEach",
+    "find",
+    "findIndex",
+    "some",
+    "every",
+    "includes",
+    "indexOf",
+    "lastIndexOf",
+    "sort",
+    "reverse",
+    "flat",
+    "flatMap",
+    "keys",
+    "values",
+    "entries",
+    "fill",
+    "split",
+    "trim",
+    "trimStart",
+    "trimEnd",
+    "replace",
+    "replaceAll",
+    "match",
+    "matchAll",
+    "test",
+    "exec",
+    "padStart",
+    "padEnd",
+    "repeat",
+    "charAt",
+    "charCodeAt",
+    "codePointAt",
+    "startsWith",
+    "endsWith",
+    "toLowerCase",
+    "toUpperCase",
+    "substring",
+    "substr",
+    "localeCompare",
+    "normalize",
     // Map/Set methods
-    "get", "set", "has", "add", "delete", "clear",
+    "get",
+    "set",
+    "has",
+    "add",
+    "delete",
+    "clear",
     // Math/Date/Number members
-    "trunc", "floor", "ceil", "round", "abs", "min", "max", "random", "pow",
-    "sqrt", "log2", "log10", "sign", "now", "parse", "parseInt", "parseFloat",
-    "isInteger", "isFinite", "isNaN", "toFixed", "toISOString",
+    "trunc",
+    "floor",
+    "ceil",
+    "round",
+    "abs",
+    "min",
+    "max",
+    "random",
+    "pow",
+    "sqrt",
+    "log2",
+    "log10",
+    "sign",
+    "now",
+    "parse",
+    "parseInt",
+    "parseFloat",
+    "isInteger",
+    "isFinite",
+    "isNaN",
+    "toFixed",
+    "toISOString",
     // Promise/Function members
-    "then", "catch", "finally", "resolve", "reject", "all", "allSettled",
-    "race", "any", "call", "apply", "bind",
+    "then",
+    "catch",
+    "finally",
+    "resolve",
+    "reject",
+    "all",
+    "allSettled",
+    "race",
+    "any",
+    "call",
+    "apply",
+    "bind",
     // JSON / global constructors & functions
-    "JSON", "stringify", "Math", "Date", "Promise", "Array", "Object", "String",
-    "Number", "Boolean", "Symbol", "RegExp", "Error", "TypeError", "RangeError",
-    "Map", "Set", "WeakMap", "WeakSet", "Buffer", "URL", "URLSearchParams",
-    "isArray", "from", "of", "assign", "freeze", "create", "getOwnPropertyNames",
-    "fromEntries", "setTimeout", "setInterval", "clearTimeout", "clearInterval",
-    "queueMicrotask", "structuredClone", "fetch", "console", "process",
-    "require", "encodeURIComponent", "decodeURIComponent", "encodeURI",
-    "decodeURI", "atob", "btoa",
+    "JSON",
+    "stringify",
+    "Math",
+    "Date",
+    "Promise",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    "Boolean",
+    "Symbol",
+    "RegExp",
+    "Error",
+    "TypeError",
+    "RangeError",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Buffer",
+    "URL",
+    "URLSearchParams",
+    "isArray",
+    "from",
+    "of",
+    "assign",
+    "freeze",
+    "create",
+    "getOwnPropertyNames",
+    "fromEntries",
+    "setTimeout",
+    "setInterval",
+    "clearTimeout",
+    "clearInterval",
+    "queueMicrotask",
+    "structuredClone",
+    "fetch",
+    "console",
+    "process",
+    "require",
+    "encodeURIComponent",
+    "decodeURIComponent",
+    "encodeURI",
+    "decodeURI",
+    "atob",
+    "btoa",
     // console members
-    "warn", "info", "debug", "trace", "table", "dir", "group", "groupEnd",
-    "assert", "time", "timeEnd",
+    "warn",
+    "info",
+    "debug",
+    "trace",
+    "table",
+    "dir",
+    "group",
+    "groupEnd",
+    "assert",
+    "time",
+    "timeEnd",
 ]);
 /** True when an UNRESOLVED callee name is a known JS/TS builtin. */
 function isBuiltinCallee(name) {

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

@@ -46,10 +46,10 @@ exports.ProjectBatchProcessor = void 0;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const vector_db_1 = require("../store/vector-db");
 const cache_check_1 = require("../utils/cache-check");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
-const vector_db_1 = require("../store/vector-db");
 const pool_1 = require("../workers/pool");
 const watcher_batch_1 = require("./watcher-batch");
 // Fast path-segment check to reject events that leak through FSEvents overflow.
@@ -164,7 +164,8 @@ class ProjectBatchProcessor {
                         break;
                     attempted.add(absPath);
                     processed++;
-                    if (batch.size > 10 && (processed % 10 === 0 || processed === batch.size)) {
+                    if (batch.size > 10 &&
+                        (processed % 10 === 0 || processed === batch.size)) {
                         (0, logger_1.log)(this.wtag, `Progress: ${processed}/${batch.size} (${reindexed} reindexed)`);
                     }
                     if (event === "unlink") {
@@ -176,15 +177,24 @@ 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;
                         }
                         // Fast path: if only mtime changed but size matches and we have a hash,
                         // verify in-process instead of dispatching to a worker (~220ms saved).
-                        if (cached && cached.hash && cached.size === stats.size) {
+                        if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
                             const buf = yield fs.promises.readFile(absPath);
                             const hash = (0, file_utils_1.computeBufferHash)(buf);
                             if (hash === cached.hash) {
@@ -319,8 +329,8 @@ class ProjectBatchProcessor {
                         }
                     }
                     if (dropped > 0) {
-                        const droppedPaths = [...batch.keys()].filter(p => !requeued.has(p));
-                        (0, logger_1.log)(this.wtag, `Dropped ${dropped} file(s) after ${MAX_RETRIES} retries: ${droppedPaths.map(p => path.basename(p)).join(", ")}`);
+                        const droppedPaths = [...batch.keys()].filter((p) => !requeued.has(p));
+                        (0, logger_1.log)(this.wtag, `Dropped ${dropped} file(s) after ${MAX_RETRIES} retries: ${droppedPaths.map((p) => path.basename(p)).join(", ")}`);
                     }
                     backoffOverrideMs = this.pending.size > 0 ? backoffMs : 0;
                 }

package/dist/lib/index/chunker.js

@@ -256,6 +256,7 @@ class TreeSitterChunker {
                 if (c.definedSymbols && c.content.length > 100) {
                     const extra = [];
                     let m;
+                    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex exec loop
                     while ((m = PROP_FN_RE.exec(c.content)) !== null) {
                         const name = m[1];
                         if (name.length > 1 && !c.definedSymbols.includes(name)) {
@@ -278,6 +279,7 @@ class TreeSitterChunker {
                 const existing = new Set(c.referencedSymbols);
                 let jm;
                 const jsxRefs = [];
+                // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex exec loop
                 while ((jm = JSX_RE.exec(c.content)) !== null) {
                     // Extract base component name (e.g., "Foo" from "Foo.Bar")
                     const full = jm[1];

package/dist/lib/index/syncer.js

@@ -55,11 +55,11 @@ exports.initialSync = initialSync;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
-const logger_1 = require("../utils/logger");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
 // isIndexableFile no longer used — extension check inlined for performance
 const lock_1 = require("../utils/lock");
+const logger_1 = require("../utils/logger");
 const project_root_1 = require("../utils/project-root");
 const pool_1 = require("../workers/pool");
 const index_config_1 = require("./index-config");
@@ -74,13 +74,24 @@ function flushBatch(db, meta, vectors, pendingMeta, pendingDeletes, dryRun) {
     return __awaiter(this, void 0, void 0, function* () {
         if (dryRun)
             return;
-        // 1. Write to VectorDB first (source of truth for data)
-        if (pendingDeletes.length > 0) {
-            yield db.deletePaths(pendingDeletes);
-        }
+        // 1. Insert the new vectors FIRST, then delete the old chunks for those paths
+        //    (excluding the just-inserted ids). Deleting first would leave a file
+        //    unsearchable if the insert then fails — the old, still-valid chunks would
+        //    already be gone. Mirrors batch-processor's insert-first flush. Paths in
+        //    pendingDeletes with no new vectors (emptied / non-indexable files) match
+        //    no excluded id, so all their old chunks are removed.
+        const newIds = vectors.map((v) => v.id);
         if (vectors.length > 0) {
             yield db.insertBatch(vectors);
         }
+        if (pendingDeletes.length > 0) {
+            if (newIds.length > 0) {
+                yield db.deletePathsExcludingIds(pendingDeletes, newIds);
+            }
+            else {
+                yield db.deletePaths(pendingDeletes);
+            }
+        }
         // 2. Update MetaCache only after VectorDB write succeeds
         for (const [p, entry] of pendingMeta.entries()) {
             meta.put(p, entry);
@@ -173,7 +184,8 @@ function initialSync(options) {
                     }
                     projectKeys.clear();
                 }
-                else if (projectKeys.size > 0 && vectorFileCount < projectKeys.size * 0.8) {
+                else if (projectKeys.size > 0 &&
+                    vectorFileCount < projectKeys.size * 0.8) {
                     (0, logger_1.log)("index", `Partial cache detected: ${vectorFileCount} files in vectors vs ${projectKeys.size} in cache — clearing cache to re-embed missing files`);
                     for (const key of projectKeys) {
                         mc.delete(key);
@@ -351,13 +363,13 @@ function initialSync(options) {
                                     return; // Broken symlink
                                 }
                             }
-                            if (!stats.isFile() || stats.size === 0 || stats.size > config_1.MAX_FILE_SIZE_BYTES) {
+                            if (!stats.isFile() ||
+                                stats.size === 0 ||
+                                stats.size > config_1.MAX_FILE_SIZE_BYTES) {
                                 return;
                             }
                             // Use absolute path as the key for MetaCache
-                            const cached = treatAsEmptyCache
-                                ? undefined
-                                : mc.get(absPath);
+                            const cached = treatAsEmptyCache ? undefined : mc.get(absPath);
                             if (cached &&
                                 cached.mtimeMs === stats.mtimeMs &&
                                 cached.size === stats.size) {

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

@@ -67,8 +67,17 @@ function processBatchCore(batch, metaCache, pool, signal) {
             }
             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 (metaCache.get(absPath)) {
+                        deletes.push(absPath);
+                        metaDeletes.push(absPath);
+                        reindexed++;
+                    }
                     continue;
+                }
                 const cached = metaCache.get(absPath);
                 if ((0, cache_check_1.isFileCached)(cached, stats)) {
                     continue;

package/dist/lib/llm/config.js

@@ -10,7 +10,7 @@ function envInt(key, fallback) {
     return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 function getLlmConfig() {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return {
         model: (_a = process.env.GMAX_LLM_MODEL) !== null && _a !== void 0 ? _a : DEFAULT_MODEL,
         binary: (_b = process.env.GMAX_LLM_BINARY) !== null && _b !== void 0 ? _b : "llama-server",
@@ -21,5 +21,6 @@ function getLlmConfig() {
         maxTokens: envInt("GMAX_LLM_MAX_TOKENS", 8192),
         idleTimeoutMin: envInt("GMAX_LLM_IDLE_TIMEOUT", 30),
         startupWaitSec: envInt("GMAX_LLM_STARTUP_WAIT", 60),
+        reasoningFormat: (_d = process.env.GMAX_LLM_REASONING_FORMAT) !== null && _d !== void 0 ? _d : "deepseek",
     };
 }