grepmax 0.21.3 → 0.23.0

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

@@ -63,6 +63,7 @@ class ProjectBatchProcessor {
         this.pending = new Map();
         this.retryCount = new Map();
         this.debounceTimer = null;
+        this.activeBatch = null;
         this.processing = false;
         this.closed = false;
         this.currentBatchAc = null;
@@ -105,14 +106,34 @@ class ProjectBatchProcessor {
             var _a;
             this.closed = true;
             (_a = this.currentBatchAc) === null || _a === void 0 ? void 0 : _a.abort();
-            if (this.debounceTimer)
+            if (this.debounceTimer) {
                 clearTimeout(this.debounceTimer);
+                this.debounceTimer = null;
+            }
+            if (this.activeBatch) {
+                yield this.activeBatch;
+            }
         });
     }
     scheduleBatch() {
         if (this.debounceTimer)
             clearTimeout(this.debounceTimer);
-        this.debounceTimer = setTimeout(() => this.processBatch(), DEBOUNCE_MS);
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            this.startBatch();
+        }, DEBOUNCE_MS);
+    }
+    startBatch() {
+        if (this.activeBatch)
+            return;
+        const run = this.processBatch().catch((err) => {
+            console.error(`[${this.wtag}] Batch processing failed:`, err);
+        });
+        this.activeBatch = run;
+        void run.finally(() => {
+            if (this.activeBatch === run)
+                this.activeBatch = null;
+        });
     }
     processBatch() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -124,7 +145,10 @@ class ProjectBatchProcessor {
                 (0, logger_1.log)(this.wtag, "Disk critically low — deferring batch processing");
                 if (this.debounceTimer)
                     clearTimeout(this.debounceTimer);
-                this.debounceTimer = setTimeout(() => this.processBatch(), 60000);
+                this.debounceTimer = setTimeout(() => {
+                    this.debounceTimer = null;
+                    this.startBatch();
+                }, 60000);
                 return;
             }
             this.processing = true;
@@ -158,11 +182,10 @@ class ProjectBatchProcessor {
                 const vectors = [];
                 const metaUpdates = new Map();
                 const metaDeletes = [];
-                const attempted = new Set();
+                const completed = new Set();
                 for (const [absPath, event] of batch) {
                     if (batchAc.signal.aborted)
                         break;
-                    attempted.add(absPath);
                     processed++;
                     if (batch.size > 10 &&
                         (processed % 10 === 0 || processed === batch.size)) {
@@ -172,6 +195,7 @@ class ProjectBatchProcessor {
                         deletes.push(absPath);
                         metaDeletes.push(absPath);
                         reindexed++;
+                        completed.add(absPath);
                         continue;
                     }
                     // change or add
@@ -186,10 +210,12 @@ class ProjectBatchProcessor {
                                 metaDeletes.push(absPath);
                                 reindexed++;
                             }
+                            completed.add(absPath);
                             continue;
                         }
                         const cached = this.metaCache.get(absPath);
                         if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                            completed.add(absPath);
                             continue;
                         }
                         // Fast path: if only mtime changed but size matches and we have a hash,
@@ -199,6 +225,7 @@ class ProjectBatchProcessor {
                             const hash = (0, file_utils_1.computeContentHash)(buf, absPath);
                             if (hash === cached.hash) {
                                 metaUpdates.set(absPath, Object.assign(Object.assign({}, cached), { mtimeMs: stats.mtimeMs }));
+                                completed.add(absPath);
                                 continue;
                             }
                         }
@@ -213,12 +240,14 @@ class ProjectBatchProcessor {
                         };
                         if (cached && cached.hash === result.hash) {
                             metaUpdates.set(absPath, metaEntry);
+                            completed.add(absPath);
                             continue;
                         }
                         if (result.shouldDelete) {
                             deletes.push(absPath);
                             metaUpdates.set(absPath, metaEntry);
                             reindexed++;
+                            completed.add(absPath);
                             continue;
                         }
                         deletes.push(absPath);
@@ -227,6 +256,7 @@ class ProjectBatchProcessor {
                         }
                         metaUpdates.set(absPath, metaEntry);
                         reindexed++;
+                        completed.add(absPath);
                     }
                     catch (err) {
                         if (batchAc.signal.aborted)
@@ -236,6 +266,7 @@ class ProjectBatchProcessor {
                             deletes.push(absPath);
                             metaDeletes.push(absPath);
                             reindexed++;
+                            completed.add(absPath);
                         }
                         else {
                             console.error(`[${this.wtag}] Failed to process ${absPath}:`, err);
@@ -243,12 +274,14 @@ class ProjectBatchProcessor {
                                 console.error(`[${this.wtag}] Worker pool unhealthy, aborting batch`);
                                 break;
                             }
+                            completed.add(absPath);
                         }
                     }
                 }
-                // Requeue files that weren't attempted (aborted or pool unhealthy)
+                // Requeue files that didn't reach a terminal outcome. This includes the
+                // file whose worker was in flight when the batch was aborted.
                 for (const [absPath, event] of batch) {
-                    if (!attempted.has(absPath) && !this.pending.has(absPath)) {
+                    if (!completed.has(absPath) && !this.pending.has(absPath)) {
                         this.pending.set(absPath, event);
                     }
                 }
@@ -339,11 +372,14 @@ class ProjectBatchProcessor {
                 clearTimeout(batchTimeout);
                 this.currentBatchAc = null;
                 this.processing = false;
-                if (this.pending.size > 0) {
+                if (!this.closed && this.pending.size > 0) {
                     if (backoffOverrideMs > 0) {
                         if (this.debounceTimer)
                             clearTimeout(this.debounceTimer);
-                        this.debounceTimer = setTimeout(() => this.processBatch(), backoffOverrideMs);
+                        this.debounceTimer = setTimeout(() => {
+                            this.debounceTimer = null;
+                            this.startBatch();
+                        }, backoffOverrideMs);
                     }
                     else {
                         this.scheduleBatch();

package/dist/lib/llm/tools.js

@@ -293,15 +293,15 @@ function executeImpact(args, ctx) {
         if (!target)
             return "(error: missing target)";
         const depth = clampDepth(args.depth);
-        const { symbols, resolvedAsFile } = yield (0, impact_1.resolveTargetSymbols)(target, ctx.vectorDb, ctx.projectRoot);
+        const { symbols, resolvedAsFile, symbolFamilies } = yield (0, impact_1.resolveTargetSymbols)(target, ctx.vectorDb, ctx.projectRoot);
         if (symbols.length === 0)
             return "(not found)";
         const excludePaths = resolvedAsFile
             ? new Set([path.resolve(ctx.projectRoot, target)])
             : undefined;
         const [deps, tests] = yield Promise.all([
-            (0, impact_1.findDependents)(symbols, ctx.vectorDb, ctx.projectRoot, excludePaths),
-            (0, impact_1.findTests)(symbols, ctx.vectorDb, ctx.projectRoot, depth),
+            (0, impact_1.findDependents)(symbols, ctx.vectorDb, ctx.projectRoot, excludePaths, undefined, undefined, symbolFamilies),
+            (0, impact_1.findTests)(symbols, ctx.vectorDb, ctx.projectRoot, depth, undefined, symbolFamilies),
         ]);
         if (deps.length === 0 && tests.length === 0)
             return "(no impact detected)";

package/dist/lib/search/searcher.js

@@ -374,7 +374,7 @@ class Searcher {
     }
     search(query, top_k, _search_options, _filters, pathPrefix, intent, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
             const finalLimit = top_k !== null && top_k !== void 0 ? top_k : 10;
             // ColBERT rerank is opt-in as of v0.17.1. On the 97-case eval it
             // regresses MRR@10 by ~3% and doubles query latency; sweep across
@@ -413,7 +413,7 @@ class Searcher {
             try {
                 table = yield this.db.ensureTable();
             }
-            catch (_q) {
+            catch (_r) {
                 return { data: [] };
             }
             // Ensure FTS index exists (lazy init, retry periodically on failure)
@@ -496,7 +496,7 @@ class Searcher {
                             this.ftsAvailable = true;
                             console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
                         }
-                        catch (_r) { }
+                        catch (_s) { }
                     }
                     else {
                         console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
@@ -670,6 +670,10 @@ class Searcher {
             if (stage2Candidates.length === 0) {
                 return { data: [] };
             }
+            const envMaxPerFile = Number.parseInt((_m = process.env.GMAX_MAX_PER_FILE) !== null && _m !== void 0 ? _m : "", 10);
+            const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
+            const displayWindow = Math.min(stage2Candidates.length, Math.max(finalLimit * MAX_PER_FILE, finalLimit, RERANK_TOP));
+            const displayCandidates = stage2Candidates.slice(0, displayWindow);
             const rerankCandidates = stage2Candidates.slice(0, RERANK_TOP);
             // Symbol-definition promotion (1/2): membership. For a bare-symbol query,
             // ensure the chunk(s) that actually DEFINE the symbol reach the rerank set
@@ -681,6 +685,7 @@ class Searcher {
             // (2/2) below then lets them win dedup over their own method-child chunks.
             if (symbolQuery && rerankCandidates.length > 0) {
                 const present = new Set(rerankCandidates.map((d) => d.id).filter(Boolean));
+                const displayPresent = new Set(displayCandidates.map((d) => d.id).filter(Boolean));
                 const MAX_INJECT = 5;
                 let injected = 0;
                 for (const d of topCandidates) {
@@ -691,6 +696,10 @@ class Searcher {
                     if (readSymbolArray(d.defined_symbols).includes(symbolQuery)) {
                         rerankCandidates.push(d);
                         present.add(d.id);
+                        if (!displayPresent.has(d.id)) {
+                            displayCandidates.push(d);
+                            displayPresent.add(d.id);
+                        }
                         injected++;
                     }
                 }
@@ -719,8 +728,9 @@ class Searcher {
                     }
                 }
             }
-            const scores = doRerank
-                ? yield pool.rerank({
+            const rerankScoreByKey = new Map();
+            if (doRerank && rerankCandidates.length > 0) {
+                const scores = yield pool.rerank({
                     query: queryMatrixRaw,
                     docs: rerankCandidates.map((doc) => {
                         var _a;
@@ -733,28 +743,25 @@ class Searcher {
                         });
                     }),
                     colbertDim,
-                }, signal)
-                : rerankCandidates.map((doc, idx) => {
-                    var _a;
-                    // If rerank is disabled, fall back to fusion ordering with structural boost
+                }, signal);
+                for (const [idx, doc] of rerankCandidates.entries()) {
                     const key = doc.id || `${doc.path}:${doc.chunk_index}`;
-                    const fusedScore = (_a = candidateScores.get(key)) !== null && _a !== void 0 ? _a : 0;
-                    // Small tie-breaker so later items don't all share 0
-                    return fusedScore || 1 / (idx + 1);
-                });
+                    rerankScoreByKey.set(key, (_o = scores === null || scores === void 0 ? void 0 : scores[idx]) !== null && _o !== void 0 ? _o : 0);
+                }
+            }
             // Symbol-definition promotion (2/2): score. Multiplicatively boost any
             // candidate that defines the queried symbol so the definition chunk outranks
             // its own method-child chunks (e.g. the `BeyondError` class chunk vs its
             // constructor/toJSON, which otherwise score higher on the literal and evict
             // the parent in overlap dedup). Multiplicative keeps it scale-invariant
             // across the rerank-on (ColBERT maxsim) and rerank-off (fusion) score ranges.
-            const envDefBoost = Number.parseFloat((_m = process.env.GMAX_DEF_BOOST) !== null && _m !== void 0 ? _m : "");
+            const envDefBoost = Number.parseFloat((_p = process.env.GMAX_DEF_BOOST) !== null && _p !== void 0 ? _p : "");
             const DEF_MATCH_BOOST = Number.isFinite(envDefBoost) && envDefBoost >= 1 ? envDefBoost : 5;
-            const scored = rerankCandidates.map((doc, idx) => {
+            const scored = displayCandidates.map((doc, idx) => {
                 var _a, _b;
-                const base = (_a = scores === null || scores === void 0 ? void 0 : scores[idx]) !== null && _a !== void 0 ? _a : 0;
                 const key = doc.id || `${doc.path}:${doc.chunk_index}`;
-                const fusedScore = (_b = candidateScores.get(key)) !== null && _b !== void 0 ? _b : 0;
+                const fusedScore = (_a = candidateScores.get(key)) !== null && _a !== void 0 ? _a : 0;
+                const base = (_b = rerankScoreByKey.get(key)) !== null && _b !== void 0 ? _b : (fusedScore || 1 / (idx + 1));
                 const blended = base + FUSED_WEIGHT * fusedScore;
                 let boosted = this.applyStructureBoost(doc, blended, searchIntent);
                 if (symbolQuery &&
@@ -782,7 +789,7 @@ class Searcher {
                 try {
                     const { scores: prScores, max: prMax } = yield (0, pagerank_1.loadOrComputePageRank)(this.db, pathPrefix);
                     if (prMax > 0) {
-                        const envWeight = Number.parseFloat((_o = process.env.GMAX_PR_WEIGHT) !== null && _o !== void 0 ? _o : "");
+                        const envWeight = Number.parseFloat((_q = process.env.GMAX_PR_WEIGHT) !== null && _q !== void 0 ? _q : "");
                         const PR_WEIGHT = Number.isFinite(envWeight) && envWeight >= 0 ? envWeight : 0.05;
                         for (const item of scored) {
                             const raw = item.record
@@ -799,7 +806,7 @@ class Searcher {
                                         defs = arr.filter((v) => typeof v === "string");
                                     }
                                 }
-                                catch (_s) { }
+                                catch (_t) { }
                             }
                             const norm = (0, pagerank_1.pageRankBoostForSymbols)(defs, prScores, prMax);
                             item.score += PR_WEIGHT * norm;
@@ -817,8 +824,6 @@ class Searcher {
             // Item 10: Per-file diversification
             const seenFiles = new Map();
             const diversified = [];
-            const envMaxPerFile = Number.parseInt((_p = process.env.GMAX_MAX_PER_FILE) !== null && _p !== void 0 ? _p : "", 10);
-            const MAX_PER_FILE = Number.isFinite(envMaxPerFile) && envMaxPerFile > 0 ? envMaxPerFile : 3;
             for (const item of uniqueScored) {
                 const path = item.record.path || "";
                 const count = seenFiles.get(path) || 0;

package/dist/lib/store/vector-db.js

@@ -68,6 +68,17 @@ function isLanceCorruptionError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return /Not found:.*\.lance(?:[^a-z]|$)/i.test(msg);
 }
+function isMissingTableError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const tableMissing = /table.*chunks.*(?:not found|does not exist)/i.test(msg) ||
+        /(?:not found|does not exist).*table.*chunks/i.test(msg) ||
+        /no such table.*chunks/i.test(msg);
+    if (tableMissing)
+        return true;
+    if (isLanceCorruptionError(err))
+        return false;
+    return false;
+}
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 class VectorDB {
@@ -389,21 +400,24 @@ class VectorDB {
     ensureTable() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield this.getDb();
+            let table;
             try {
-                const table = yield db.openTable(TABLE_NAME);
-                yield this.validateSchema(table);
-                yield this.evolveSchema(table);
-                return table;
+                table = yield db.openTable(TABLE_NAME);
             }
-            catch (_err) {
+            catch (err) {
+                if (!isMissingTableError(err))
+                    throw err;
                 (0, logger_1.log)("db", `Creating table (${this.vectorDim}d)`);
                 const schema = this.buildSchema();
-                const table = yield db.createTable(TABLE_NAME, [this.seedRow()], {
+                table = yield db.createTable(TABLE_NAME, [this.seedRow()], {
                     schema,
                 });
                 yield table.delete('id = "seed"');
                 return table;
             }
+            yield this.validateSchema(table);
+            yield this.evolveSchema(table);
+            return table;
         });
     }
     insertBatch(records) {

package/dist/lib/utils/daemon-client.js

@@ -47,6 +47,7 @@ exports.isDaemonRunning = isDaemonRunning;
 exports.isDaemonHeartbeatFresh = isDaemonHeartbeatFresh;
 exports.readDaemonPid = readDaemonPid;
 exports.waitForProcessExit = waitForProcessExit;
+exports.waitForDaemonDrain = waitForDaemonDrain;
 exports.writeDrainingMarker = writeDrainingMarker;
 exports.clearDrainingMarker = clearDrainingMarker;
 exports.isDaemonDraining = isDaemonDraining;
@@ -56,6 +57,8 @@ const fs = __importStar(require("node:fs"));
 const net = __importStar(require("node:net"));
 const config_1 = require("../../config");
 const DEFAULT_TIMEOUT_MS = 5000;
+const DAEMON_READY_TIMEOUT_MS = 30000;
+const DAEMON_READY_POLL_MS = 200;
 // A live daemon refreshes daemon.lock mtime every 60s (HEARTBEAT_INTERVAL_MS).
 // Treat mtime younger than 2.5x that as proof of life, even if a ping times
 // out — a busy daemon with a blocked event loop can still be heartbeating.
@@ -126,6 +129,15 @@ function isDaemonRunning(opts) {
         return resp.ok === true;
     });
 }
+function isDaemonReady(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const resp = yield sendDaemonCommand({ cmd: "ping" }, { timeoutMs: (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : 2000 });
+        // Old daemons do not include `ready`; treat missing as ready so an upgraded
+        // CLI does not hang on a still-running daemon from the previous release.
+        return resp.ok === true && resp.ready !== false;
+    });
+}
 /**
  * Lock-file-based liveness probe. A running daemon refreshes daemon.lock's
  * mtime every 60s via its heartbeat loop; a fresh mtime means the daemon is
@@ -194,6 +206,11 @@ function waitForProcessExit(pid, timeoutMs) {
 // LLM/MLX teardown. Treat a draining marker as authoritative for this long; past
 // it, assume the draining daemon wedged and let killStaleProcesses reclaim it.
 const DRAIN_GRACE_MS = 90000;
+function waitForDaemonDrain(pid_1) {
+    return __awaiter(this, arguments, void 0, function* (pid, timeoutMs = DRAIN_GRACE_MS) {
+        return waitForProcessExit(pid, timeoutMs);
+    });
+}
 /**
  * Record that this daemon (pid) has begun graceful shutdown, so a successor's
  * killStaleProcesses() won't SIGKILL it mid-cleanup after it drops its
@@ -240,20 +257,23 @@ function isDaemonDraining(pid) {
     }
 }
 /**
- * Ensure the daemon is running — start it if needed, poll up to 5s.
+ * Ensure the daemon is running — start it if needed, then wait for resources.
  * Returns true if daemon is ready, false if it couldn't be started.
  */
 function ensureDaemonRunning() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (yield isDaemonRunning())
+        if (yield isDaemonReady())
             return true;
-        const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
-        const pid = spawnDaemon();
-        if (!pid)
-            return false;
-        for (let i = 0; i < 25; i++) {
-            yield new Promise((r) => setTimeout(r, 200));
-            if (yield isDaemonRunning())
+        if (!(yield isDaemonRunning())) {
+            const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
+            const pid = spawnDaemon();
+            if (!pid)
+                return false;
+        }
+        const deadline = Date.now() + DAEMON_READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            yield new Promise((r) => setTimeout(r, DAEMON_READY_POLL_MS));
+            if (yield isDaemonReady())
                 return true;
         }
         return false;
@@ -315,6 +335,12 @@ function sendStreamingCommand(cmd, onProgress, opts) {
                         // (DB flush, compaction). Reset the watchdog; do not surface.
                         resetTimer();
                     }
+                    else if (msg.ok === false) {
+                        const error = typeof msg.error === "string"
+                            ? msg.error
+                            : "daemon command failed";
+                        finish(new Error(error));
+                    }
                 }
                 catch (_a) {
                     console.warn("[daemon-client] Malformed response line:", line.slice(0, 200));

package/dist/lib/workers/pool.js

@@ -203,6 +203,7 @@ class WorkerPool {
         this.destroyed = false;
         this.destroyPromise = null;
         this.consecutiveRespawns = 0;
+        this.respawnLimitReached = false;
         this.idleReapInterval = null;
         const resolved = resolveProcessWorker();
         this.modulePath = resolved.filename;
@@ -246,6 +247,37 @@ class WorkerPool {
         if (idx !== -1)
             this.taskQueue.splice(idx, 1);
     }
+    hasUnassignedTasks() {
+        const hasUnassigned = (queue) => queue.some((id) => {
+            const t = this.tasks.get(id);
+            return t && !t.worker;
+        });
+        return hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
+    }
+    rejectUnassignedTasks(message) {
+        for (const task of Array.from(this.tasks.values())) {
+            if (task.worker)
+                continue;
+            task.reject(new Error(message));
+            this.completeTask(task, null);
+        }
+    }
+    maybeRespawn(reason, hasPendingTasks) {
+        if (this.destroyed || this.respawnLimitReached)
+            return false;
+        this.consecutiveRespawns++;
+        (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after ${reason} (workers=${this.workers.length} pending=${hasPendingTasks})`);
+        if (this.consecutiveRespawns > WorkerPool.MAX_RESPAWNS) {
+            this.respawnLimitReached = true;
+            const message = `Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`;
+            console.error(`[pool] ${message}`);
+            if (this.workers.length === 0)
+                this.rejectUnassignedTasks(message);
+            return false;
+        }
+        this.spawnWorker();
+        return true;
+    }
     completeTask(task, worker) {
         this.clearTaskTimeout(task);
         this.tasks.delete(task.id);
@@ -280,19 +312,9 @@ class WorkerPool {
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
             // Only respawn if we have no workers left or there are pending tasks
-            const hasUnassigned = (queue) => queue.some((id) => {
-                const t = this.tasks.get(id);
-                return t && !t.worker;
-            });
-            const hasPendingTasks = hasUnassigned(this.priorityQueue) || hasUnassigned(this.taskQueue);
+            const hasPendingTasks = this.hasUnassignedTasks();
             if (this.workers.length === 0 || hasPendingTasks) {
-                this.consecutiveRespawns++;
-                (0, logger_1.log)("pool", `respawn #${this.consecutiveRespawns} after exit (workers=${this.workers.length} pending=${hasPendingTasks})`);
-                if (this.consecutiveRespawns > WorkerPool.MAX_RESPAWNS) {
-                    console.error(`[pool] Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`);
-                    return;
-                }
-                this.spawnWorker();
+                this.maybeRespawn(reason, hasPendingTasks);
             }
             this.dispatch();
         }
@@ -350,6 +372,7 @@ class WorkerPool {
             }
             this.completeTask(task, worker);
             this.consecutiveRespawns = 0;
+            this.respawnLimitReached = false;
             this.recycleIfBloated(worker);
             this.dispatch();
         };
@@ -452,7 +475,7 @@ class WorkerPool {
         catch (_e) { }
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
-            this.spawnWorker();
+            this.maybeRespawn(`timeout (${reason})`, this.hasUnassignedTasks());
         }
         this.dispatch();
     }
@@ -472,6 +495,12 @@ class WorkerPool {
             return;
         // Lazy spawn: if no idle worker and below max, spawn one
         if (!idle && this.workers.length < this.maxWorkers) {
+            if (this.respawnLimitReached) {
+                if (this.workers.length === 0) {
+                    this.rejectUnassignedTasks(`Worker respawn limit reached (${WorkerPool.MAX_RESPAWNS}). Not spawning more workers.`);
+                }
+                return;
+            }
             this.spawnWorker();
             idle = this.workers[this.workers.length - 1];
         }
@@ -691,22 +720,35 @@ class WorkerPool {
             this.taskQueue = [];
             this.priorityQueue = [];
             const killPromises = this.workers.map((w) => new Promise((resolve) => {
+                var _a, _b;
+                let settled = false;
+                let force;
+                let fallback;
+                const cleanup = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (force)
+                        clearTimeout(force);
+                    if (fallback)
+                        clearTimeout(fallback);
+                    resolve();
+                };
                 w.cleanedUp = true;
                 w.child.removeAllListeners("message");
                 w.child.removeAllListeners("exit");
                 w.child.removeAllListeners("error");
-                w.child.once("exit", () => resolve());
-                w.child.kill("SIGTERM");
-                const force = setTimeout(() => {
+                w.child.once("exit", cleanup);
+                force = setTimeout(() => {
                     try {
                         w.child.kill("SIGKILL");
                     }
                     catch (_a) { }
                 }, FORCE_KILL_GRACE_MS);
-                setTimeout(() => {
-                    clearTimeout(force);
-                    resolve();
-                }, config_1.WORKER_TIMEOUT_MS);
+                (_a = force.unref) === null || _a === void 0 ? void 0 : _a.call(force);
+                fallback = setTimeout(cleanup, config_1.WORKER_TIMEOUT_MS);
+                (_b = fallback.unref) === null || _b === void 0 ? void 0 : _b.call(fallback);
+                w.child.kill("SIGTERM");
             }));
             this.destroyPromise = Promise.allSettled(killPromises).then(() => {
                 this.workers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.21.3",
+  "version": "0.23.0",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/reowens/grepmax.git"
   },
-  "main": "index.js",
+  "main": "dist/index.js",
   "bin": {
     "gmax": "dist/index.js"
   },
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
-    "prebuild": "mkdir -p dist",
+    "prebuild": "rm -rf dist tsconfig.tsbuildinfo && mkdir -p dist",
     "build": "tsc",
     "postbuild": "chmod +x dist/index.js",
     "dev": "npx tsc && node dist/index.js",
@@ -37,7 +37,7 @@
     "lint:fix": "biome check --write .",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "pnpm build",
-    "preversion": "pnpm test && pnpm typecheck",
+    "preversion": "pnpm test && pnpm typecheck && pnpm run format:check",
     "version": "bash scripts/sync-versions.sh && git add -A",
     "postversion": "bash scripts/postrelease.sh"
   },
@@ -96,6 +96,11 @@
     "web-tree-sitter": "^0.26.9",
     "zod": "^4.4.3"
   },
+  "pnpm": {
+    "overrides": {
+      "mathjs": "15.2.0"
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "2.4.10",
     "@types/node": "^26.0.1",

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.21.3",
+  "version": "0.23.0",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",
@@ -10,11 +10,5 @@
   "homepage": "https://github.com/reowens/grepmax",
   "repository": "https://github.com/reowens/grepmax",
   "license": "Apache-2.0",
-  "keywords": [
-    "search",
-    "semantic",
-    "grep",
-    "code-search",
-    "semantic-search"
-  ]
+  "keywords": ["search", "semantic", "grep", "code-search", "semantic-search"]
 }