grepmax 0.16.10 → 0.17.1

package/dist/commands/mcp.js

@@ -521,7 +521,7 @@ exports.mcp = new commander_1.Command("mcp")
                         }
                     }
                 }
-                const result = yield searcher.search(query, limit, { rerank: true }, Object.keys(filters).length > 0 ? filters : undefined, pathPrefix);
+                const result = yield searcher.search(query, limit, { rerank: process.env.GMAX_RERANK === "1" }, Object.keys(filters).length > 0 ? filters : undefined, pathPrefix);
                 if (!result.data || result.data.length === 0) {
                     return ok("No matches found. Try broadening your query, using fewer keywords, or check `gmax status` to verify the project is indexed.");
                 }
@@ -1578,7 +1578,7 @@ exports.mcp = new commander_1.Command("mcp")
                 const rel = (p) => p.startsWith(`${projectRoot}/`) ? p.slice(projectRoot.length + 1) : p;
                 if (query) {
                     const searcher = getSearcher();
-                    const response = yield searcher.search(query, limit, { rerank: true }, {}, projectRoot);
+                    const response = yield searcher.search(query, limit, { rerank: process.env.GMAX_RERANK === "1" }, {}, projectRoot);
                     const changedSet = new Set(changedFiles);
                     let filtered = response.data.filter((r) => changedSet.has(String(r.path || "")));
                     if (role)
@@ -1753,7 +1753,7 @@ exports.mcp = new commander_1.Command("mcp")
             const limit = Math.min(Math.max(Number(args.limit) || 10, 1), 25);
             try {
                 const searcher = getSearcher();
-                const response = yield searcher.search(topic, limit, { rerank: true }, {}, projectRoot);
+                const response = yield searcher.search(topic, limit, { rerank: process.env.GMAX_RERANK === "1" }, {}, projectRoot);
                 if (response.data.length === 0)
                     return ok(`No results found for "${topic}".`);
                 const rel = (p) => p.startsWith(`${projectRoot}/`) ? p.slice(projectRoot.length + 1) : p;

package/dist/commands/search.js

@@ -571,7 +571,7 @@ Examples:
                             ? searchFilters
                             : undefined,
                         pathPrefix: pathFilter,
-                        rerank: true,
+                        rerank: process.env.GMAX_RERANK === "1",
                         explain: options.explain,
                         includeSkeletons: options.skeleton,
                         includeGraph: options.symbol,
@@ -668,7 +668,7 @@ Examples:
                 }
             }
             const searcher = new searcher_1.Searcher(vectorDb);
-            searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: true, explain: options.explain }, Object.keys(searchFilters).length > 0
+            searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: process.env.GMAX_RERANK === "1", explain: options.explain }, Object.keys(searchFilters).length > 0
                 ? searchFilters
                 : undefined, pathFilter);
         } // end if (!searchResult) — in-process fallback

package/dist/eval.js

@@ -572,11 +572,19 @@ function run() {
             process.exit(1);
         }
         const results = [];
-        console.log("Starting evaluation...\n");
+        const jsonModeEarly = process.env.GMAX_EVAL_JSON === "1" || process.argv.includes("--json");
+        // In JSON mode, route all human-readable preamble to stderr so stdout
+        // stays a single parseable JSON object.
+        const log = jsonModeEarly ? console.error : console.log;
+        log("Starting evaluation...\n");
         const startTime = performance.now();
+        // Rerank is OFF by default — measures pre-rerank quality so ranking-only
+        // changes show up clearly. Set GMAX_EVAL_RERANK=1 to measure the full
+        // production pipeline (slower, but more representative).
+        const rerank = process.env.GMAX_EVAL_RERANK === "1";
         for (const c of exports.cases) {
             const queryStart = performance.now();
-            const res = yield searcher.search(c.query, topK, { rerank: false });
+            const res = yield searcher.search(c.query, topK, { rerank });
             const queryEnd = performance.now();
             const timeMs = queryEnd - queryStart;
             results.push(evaluateCase(res, c, timeMs));
@@ -585,25 +593,46 @@ function run() {
         const mrr = results.reduce((sum, r) => sum + r.rr, 0) / results.length;
         const recallAt10 = results.reduce((sum, r) => sum + r.recall, 0) / results.length;
         const avgTime = results.reduce((sum, r) => sum + r.timeMs, 0) / results.length;
-        console.log("=".repeat(80));
-        console.log(`Eval results for store at: ${paths.lancedbDir}`);
-        console.log("=".repeat(80));
-        results.forEach((r) => {
-            const status = r.found ? `rank ${(1 / r.rr).toFixed(0)}` : "❌ missed";
-            const emoji = r.found ? (r.rr === 1 ? "🎯" : "✓") : "❌";
-            console.log(`${emoji} ${r.query}`);
-            console.log(`   => ${status} (target: ${r.path}) [${r.timeMs.toFixed(0)}ms]`);
-            if (r.note) {
-                console.log(`   // ${r.note}`);
-            }
-        });
-        console.log("=".repeat(80));
-        console.log(`MRR: ${mrr.toFixed(3)}`);
-        console.log(`Recall@10: ${recallAt10.toFixed(3)}`);
-        console.log(`Avg query time: ${avgTime.toFixed(0)}ms`);
-        console.log(`Total time: ${totalTime.toFixed(0)}ms`);
-        console.log(`Found: ${results.filter((r) => r.found).length}/${results.length}`);
-        console.log("=".repeat(80));
+        const summary = {
+            cases: results.length,
+            found: results.filter((r) => r.found).length,
+            hitsAt1: results.filter((r) => r.rr === 1).length,
+            mrrAt10: Number(mrr.toFixed(4)),
+            recallAt10: Number(recallAt10.toFixed(4)),
+            avgTimeMs: Math.round(avgTime),
+            totalTimeMs: Math.round(totalTime),
+            storePath: paths.lancedbDir,
+            rerank,
+        };
+        // JSON mode (GMAX_EVAL_JSON=1 or --json arg) emits a single stable object
+        // on stdout for tooling. Human output goes to stderr so both can be
+        // captured separately. Public-compatible shape — adding fixtures later
+        // doesn't change the schema.
+        const jsonMode = process.env.GMAX_EVAL_JSON === "1" || process.argv.includes("--json");
+        if (jsonMode) {
+            process.stdout.write(`${JSON.stringify({ summary, results }, null, 2)}\n`);
+        }
+        else {
+            console.log("=".repeat(80));
+            console.log(`Eval results for store at: ${paths.lancedbDir}`);
+            console.log("=".repeat(80));
+            results.forEach((r) => {
+                const status = r.found ? `rank ${(1 / r.rr).toFixed(0)}` : "❌ missed";
+                const emoji = r.found ? (r.rr === 1 ? "🎯" : "✓") : "❌";
+                console.log(`${emoji} ${r.query}`);
+                console.log(`   => ${status} (target: ${r.path}) [${r.timeMs.toFixed(0)}ms]`);
+                if (r.note) {
+                    console.log(`   // ${r.note}`);
+                }
+            });
+            console.log("=".repeat(80));
+            console.log(`MRR: ${mrr.toFixed(3)}`);
+            console.log(`Recall@10: ${recallAt10.toFixed(3)}`);
+            console.log(`Avg query time: ${avgTime.toFixed(0)}ms`);
+            console.log(`Total time: ${totalTime.toFixed(0)}ms`);
+            console.log(`Found: ${summary.found}/${results.length}`);
+            console.log("=".repeat(80));
+        }
         yield (0, exit_1.gracefulExit)(0);
     });
 }

package/dist/lib/daemon/daemon.js

@@ -109,6 +109,8 @@ class Daemon {
         this.startTime = Date.now();
         this.heartbeatInterval = null;
         this.idleInterval = null;
+        this.heartbeatTick = 0;
+        this.mlxRecoveryInFlight = false;
         this.shuttingDown = false;
         this.pendingOps = new Set();
         this.watcherFailCount = new Map();
@@ -289,6 +291,14 @@ class Daemon {
                 }
                 catch (_a) { }
                 (0, log_rotate_1.rotateLogFds)(path.join(config_1.PATHS.logsDir, "daemon.log"));
+                // Every 5 ticks (5 min), probe the MLX embed server and respawn if
+                // it's gone zombie (port held but /health unresponsive). Closes the
+                // 42h-degradation window where workers silently fell back to ONNX CPU
+                // after a frozen MLX process kept the port bound (v0.17.0 bug #1).
+                this.heartbeatTick++;
+                if (this.heartbeatTick % 5 === 0) {
+                    void this.checkMlxHealth();
+                }
             }, HEARTBEAT_INTERVAL_MS);
             // 10. Idle timeout (skip when disabled via env)
             if (IDLE_TIMEOUT_MS > 0) {
@@ -796,7 +806,7 @@ class Daemon {
             this.lastActivity = Date.now();
             let result;
             try {
-                result = yield searcher.search(payload.query, payload.limit, { rerank: payload.rerank !== false, explain: payload.explain === true }, payload.filters, payload.pathPrefix, undefined, signal);
+                result = yield searcher.search(payload.query, payload.limit, { rerank: payload.rerank === true, explain: payload.explain === true }, payload.filters, payload.pathPrefix, undefined, signal);
             }
             catch (err) {
                 if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError") {
@@ -910,6 +920,7 @@ class Daemon {
                 conn.on("close", () => ac.abort());
                 this.shutdownAbortControllers.add(ac);
                 this.vectorDb.pauseMaintenanceLoop();
+                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
                 let lastProgressTime = 0;
                 try {
                     const result = yield (0, syncer_1.initialSync)({
@@ -934,6 +945,7 @@ class Daemon {
                     if (!this.shuttingDown) {
                         yield this.watchProject(root);
                     }
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, {
                         ok: true,
                         processed: result.processed,
@@ -945,9 +957,11 @@ class Daemon {
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
                     console.error(`[daemon] addProject failed for ${path.basename(root)}:`, msg);
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
                 }
                 finally {
+                    stopHeartbeat();
                     this.shutdownAbortControllers.delete(ac);
                     (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
                 }
@@ -977,6 +991,7 @@ class Daemon {
                 conn.on("close", () => ac.abort());
                 this.shutdownAbortControllers.add(ac);
                 this.vectorDb.pauseMaintenanceLoop();
+                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
                 let lastProgressTime = 0;
                 try {
                     const result = yield (0, syncer_1.initialSync)({
@@ -1000,6 +1015,7 @@ class Daemon {
                             });
                         },
                     });
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, {
                         ok: true,
                         processed: result.processed,
@@ -1011,9 +1027,11 @@ class Daemon {
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
                     console.error(`[daemon] indexProject failed for ${path.basename(root)}:`, msg);
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
                 }
                 finally {
+                    stopHeartbeat();
                     this.shutdownAbortControllers.delete(ac);
                     (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.resumeMaintenanceLoop();
                     // Re-enable watcher (skip if shutting down)
@@ -1036,6 +1054,7 @@ class Daemon {
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: "daemon resources not ready" });
                     return;
                 }
+                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
                 try {
                     yield this.unwatchProject(root);
                     const rootPrefix = root.endsWith("/") ? root : `${root}/`;
@@ -1044,13 +1063,18 @@ class Daemon {
                     for (const key of keys) {
                         this.metaCache.delete(key);
                     }
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, { ok: true });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
                     console.error(`[daemon] removeProject failed for ${path.basename(root)}:`, msg);
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
                 }
+                finally {
+                    stopHeartbeat();
+                }
             }));
         });
     }
@@ -1063,6 +1087,7 @@ class Daemon {
                     return;
                 }
                 const rootPrefix = (_a = opts.pathPrefix) !== null && _a !== void 0 ? _a : (root.endsWith("/") ? root : `${root}/`);
+                const stopHeartbeat = (0, ipc_handler_1.startHeartbeat)(conn);
                 let lastProgressTime = 0;
                 try {
                     const result = yield (0, syncer_1.generateSummaries)(this.vectorDb, rootPrefix, (done, total) => {
@@ -1073,6 +1098,7 @@ class Daemon {
                         lastProgressTime = now;
                         (0, ipc_handler_1.writeProgress)(conn, { summarized: done, total });
                     }, opts.limit);
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, {
                         ok: true,
                         summarized: result.summarized,
@@ -1082,8 +1108,12 @@ class Daemon {
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
                     console.error(`[daemon] summarizeProject failed for ${path.basename(root)}:`, msg);
+                    stopHeartbeat();
                     (0, ipc_handler_1.writeDone)(conn, { ok: false, error: msg });
                 }
+                finally {
+                    stopHeartbeat();
+                }
             }));
         });
     }
@@ -1165,6 +1195,31 @@ class Daemon {
             return null;
         }
     }
+    checkMlxHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shuttingDown || this.mlxRecoveryInFlight)
+                return;
+            if (yield this.isMlxServerUp())
+                return;
+            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+            const stalePid = this.getPortPid(port);
+            if (!stalePid)
+                return; // No process — let the next user-facing path spawn it.
+            this.mlxRecoveryInFlight = true;
+            try {
+                console.log(`[daemon] MLX zombie detected on port ${port} (PID ${stalePid}) — killing and respawning`);
+                yield (0, process_1.killProcess)(stalePid);
+                yield new Promise((r) => setTimeout(r, 500));
+                yield this.ensureMlxServer();
+            }
+            catch (err) {
+                console.error(`[daemon] MLX recovery failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            finally {
+                this.mlxRecoveryInFlight = false;
+            }
+        });
+    }
     ensureMlxServer(mlxModel) {
         return __awaiter(this, void 0, void 0, function* () {
             if (yield this.isMlxServerUp()) {

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

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeProgress = writeProgress;
 exports.writeDone = writeDone;
+exports.startHeartbeat = startHeartbeat;
 exports.handleCommand = handleCommand;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -73,6 +74,26 @@ function writeDone(conn, data) {
     conn.write(`${JSON.stringify(Object.assign({ type: "done" }, data))}\n`);
     conn.end();
 }
+const HEARTBEAT_INTERVAL_MS = 5000;
+/**
+ * Emit periodic heartbeat lines so the client's watchdog timer resets even
+ * when no progress is reported (e.g., during a long DB flush or compaction).
+ * The client treats heartbeat lines as proof-of-life but not as progress.
+ *
+ * Returns a stop function; caller MUST call it before writeDone to avoid a
+ * stray heartbeat racing the done line.
+ */
+function startHeartbeat(conn, intervalMs = HEARTBEAT_INTERVAL_MS) {
+    const timer = setInterval(() => {
+        if (!conn.writable) {
+            clearInterval(timer);
+            return;
+        }
+        conn.write(`${JSON.stringify({ type: "heartbeat", ts: Date.now() })}\n`);
+    }, intervalMs);
+    conn.once("close", () => clearInterval(timer));
+    return () => clearInterval(timer);
+}
 /**
  * Handle a single IPC command.
  *
@@ -148,7 +169,7 @@ function handleCommand(daemon, cmd, conn) {
                             limit: limitRaw,
                             filters,
                             pathPrefix: typeof cmd.pathPrefix === "string" ? cmd.pathPrefix : undefined,
-                            rerank: cmd.rerank !== false,
+                            rerank: cmd.rerank === true,
                             explain: cmd.explain === true,
                             includeSkeletons: cmd.includeSkeletons === true,
                             skeletonLimit: skeletonLimitRaw,

package/dist/lib/search/searcher.js

@@ -340,7 +340,11 @@ class Searcher {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             const finalLimit = top_k !== null && top_k !== void 0 ? top_k : 10;
-            const doRerank = (_a = _search_options === null || _search_options === void 0 ? void 0 : _search_options.rerank) !== null && _a !== void 0 ? _a : true;
+            // 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
+            // FUSED_WEIGHT ∈ {0,0.1,0.5,1,2} showed rerank scores dominate
+            // fused scores ~30:1 so blend tuning can't recover the loss.
+            const doRerank = (_a = _search_options === null || _search_options === void 0 ? void 0 : _search_options.rerank) !== null && _a !== void 0 ? _a : false;
             const explain = (_b = _search_options === null || _search_options === void 0 ? void 0 : _search_options.explain) !== null && _b !== void 0 ? _b : false;
             const searchIntent = intent || (0, intent_1.detectIntent)(query);
             const pool = (0, pool_1.getWorkerPool)();

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

@@ -219,6 +219,11 @@ function sendStreamingCommand(cmd, onProgress, opts) {
                         resetTimer();
                         onProgress(msg);
                     }
+                    else if (msg.type === "heartbeat") {
+                        // Proof-of-life from a daemon doing slow non-emitting work
+                        // (DB flush, compaction). Reset the watchdog; do not surface.
+                        resetTimer();
+                    }
                 }
                 catch (_a) {
                     console.warn("[daemon-client] Malformed response line:", line.slice(0, 200));

package/dist/lib/workers/orchestrator.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerOrchestrator = void 0;
+exports.coerceColbertBytes = coerceColbertBytes;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const transformers_1 = require("@huggingface/transformers");
@@ -58,6 +59,43 @@ const granite_1 = require("./embeddings/granite");
 const mlx_client_1 = require("./embeddings/mlx-client");
 const logger_1 = require("../utils/logger");
 let mlxFallbackWarned = false;
+/**
+ * Normalize a colbert payload received over IPC into an Int8Array.
+ *
+ * Node `child_process.send` serializes payloads as JSON, which doesn't
+ * preserve TypedArrays. An Int8Array sent over IPC arrives as a plain
+ * object with numeric keys (`{0: byte, 1: byte, ...}`). Without explicitly
+ * handling that shape, the rerank pipeline silently no-ops (empty matrix
+ * → maxSim returns 0 → final ranking falls back to fusion-only). Caught
+ * 2026-05-25 when the eval harness showed rerank-on producing identical
+ * scores to rerank-off across 97 cases.
+ */
+function coerceColbertBytes(col) {
+    if (col instanceof Int8Array)
+        return col;
+    if (Buffer.isBuffer(col)) {
+        return new Int8Array(col.buffer, col.byteOffset, col.byteLength);
+    }
+    if (Array.isArray(col))
+        return new Int8Array(col);
+    if (col && typeof col === "object") {
+        // {type:"Buffer", data:[...]} — Node Buffer.toJSON output
+        const asUnknown = col;
+        if (asUnknown.type === "Buffer" && Array.isArray(asUnknown.data)) {
+            return new Int8Array(asUnknown.data);
+        }
+        // {0: byte, 1: byte, ...} — Int8Array after IPC JSON serialization
+        const keys = Object.keys(col);
+        if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
+            const arr = new Int8Array(keys.length);
+            for (const k of keys) {
+                arr[Number(k)] = col[k];
+            }
+            return arr;
+        }
+    }
+    return new Int8Array(0);
+}
 const CACHE_DIR = config_1.PATHS.models;
 const LOG_MODELS = process.env.GMAX_DEBUG_MODELS === "1" ||
     process.env.GMAX_DEBUG_MODELS === "true";
@@ -330,28 +368,7 @@ class WorkerOrchestrator {
             yield this.ensureReady();
             const queryMatrix = input.query.map((row) => row instanceof Float32Array ? row : new Float32Array(row));
             return input.docs.map((doc) => {
-                const col = doc.colbert;
-                let colbert;
-                if (col instanceof Int8Array) {
-                    colbert = col;
-                }
-                else if (Buffer.isBuffer(col)) {
-                    colbert = new Int8Array(col.buffer, col.byteOffset, col.byteLength);
-                }
-                else if (col &&
-                    typeof col === "object" &&
-                    "type" in col &&
-                    col.type === "Buffer" &&
-                    Array.isArray(col.data)) {
-                    // IPC serialization fallback (still copies, but unavoidable without SharedArrayBuffer)
-                    colbert = new Int8Array(col.data);
-                }
-                else if (Array.isArray(col)) {
-                    colbert = new Int8Array(col);
-                }
-                else {
-                    colbert = new Int8Array(0);
-                }
+                const colbert = coerceColbertBytes(doc.colbert);
                 const seqLen = Math.floor(colbert.length / input.colbertDim);
                 const docMatrix = [];
                 for (let i = 0; i < seqLen; i++) {

package/dist/lib/workers/pool.js

@@ -83,6 +83,13 @@ const TASK_TIMEOUT_MS = (() => {
     return 120000;
 })();
 const FORCE_KILL_GRACE_MS = 200;
+// Longer grace for idle reaps: the worker isn't urgently in the way, and a
+// graceful SIGTERM lets ONNX free ~1GB of model memory. But if SIGTERM is
+// ignored (a worker burning 100% CPU inside a native ONNX matmul tight loop
+// won't service signals — the 42h zombie we saw in v0.17.0 validation),
+// escalate to SIGKILL. ~5s is well above ONNX teardown time but short
+// enough that the reap loop self-heals within a minute.
+const REAP_FORCE_KILL_GRACE_MS = 5000;
 class ProcessWorker {
     constructor(modulePath, execArgv, maxMemoryMb) {
         this.modulePath = modulePath;
@@ -90,6 +97,10 @@ class ProcessWorker {
         this.busy = false;
         this.pendingTaskId = null;
         this.lastBusyTime = Date.now();
+        // Set when the pool has cleaned up after this worker (via exit or error
+        // event). Guards against handleWorkerExit running twice when both events
+        // fire for the same crash.
+        this.cleanedUp = false;
         const memArgs = maxMemoryMb
             ? [`--max-old-space-size=${maxMemoryMb}`]
             : [];
@@ -166,18 +177,26 @@ class WorkerPool {
             worker.lastBusyTime = Date.now();
         }
     }
-    handleWorkerExit(worker, code, signal) {
+    handleWorkerExit(worker, code, signal, reason = "exit", err) {
         var _a, _b, _c, _d;
+        // Crash paths can fire both 'error' and 'exit'. Either is sufficient
+        // to clean up; running this twice would double-respawn.
+        if (worker.cleanedUp)
+            return;
+        worker.cleanedUp = true;
         worker.busy = false;
         const failedTasks = Array.from(this.tasks.values()).filter((t) => t.worker === worker);
         for (const task of failedTasks) {
             this.clearTaskTimeout(task);
             const filePath = (_d = (_b = (_a = task.payload) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : (_c = task.payload) === null || _c === void 0 ? void 0 : _c.absolutePath) !== null && _d !== void 0 ? _d : "unknown";
-            (0, logger_1.debug)("pool", `exit killed task=${task.id} method=${task.method} file=${filePath}`);
-            task.reject(new Error(`Worker exited unexpectedly${code ? ` (code ${code})` : ""}${signal ? ` signal ${signal}` : ""}`));
+            (0, logger_1.debug)("pool", `${reason} killed task=${task.id} method=${task.method} file=${filePath}`);
+            const exitDetail = err
+                ? `: ${err.message}`
+                : `${code ? ` (code ${code})` : ""}${signal ? ` signal ${signal}` : ""}`;
+            task.reject(new Error(`Worker ${reason === "error" ? "errored" : "exited unexpectedly"}${exitDetail}`));
             this.completeTask(task, null);
         }
-        (0, logger_1.log)("pool", `Worker PID:${worker.child.pid} exited (code:${code} signal:${signal} pending=${failedTasks.length})`);
+        (0, logger_1.log)("pool", `Worker PID:${worker.child.pid} ${reason} (code:${code} signal:${signal}${err ? ` err:${err.message}` : ""} pending=${failedTasks.length})`);
         this.workers = this.workers.filter((w) => w !== worker);
         if (!this.destroyed) {
             // Only respawn if we have no workers left or there are pending tasks
@@ -243,9 +262,14 @@ class WorkerPool {
             this.consecutiveRespawns = 0;
             this.dispatch();
         };
-        const onExit = (code, signal) => this.handleWorkerExit(worker, code, signal);
+        const onExit = (code, signal) => this.handleWorkerExit(worker, code, signal, "exit");
+        // 'error' fires when spawn fails, IPC send fails async, or the child
+        // can't be killed. Without this handler the worker stays in
+        // this.workers as a zombie that the next dispatch tries to send to.
+        const onError = (err) => this.handleWorkerExit(worker, null, null, "error", err);
         worker.child.on("message", onMessage);
         worker.child.on("exit", onExit);
+        worker.child.on("error", onError);
         this.workers.push(worker);
     }
     enqueue(method, payload, signal) {
@@ -326,8 +350,10 @@ class WorkerPool {
         (0, logger_1.log)("pool", `timeout task=${task.id} method=${task.method} file=${filePath} after ${TASK_TIMEOUT_MS}ms — killing worker PID:${worker.child.pid}`);
         this.completeTask(task, null);
         task.reject(new Error(`Worker task ${task.method} timed out after ${TASK_TIMEOUT_MS}ms on ${filePath}`));
+        worker.cleanedUp = true;
         worker.child.removeAllListeners("message");
         worker.child.removeAllListeners("exit");
+        worker.child.removeAllListeners("error");
         try {
             worker.child.kill("SIGKILL");
         }
@@ -421,13 +447,34 @@ class WorkerPool {
             .slice(0, reapCount)
             .forEach((w) => {
             (0, logger_1.log)("pool", `reap idle worker PID:${w.child.pid} (idle ${Math.round((now - w.lastBusyTime) / 1000)}s, ${this.workers.length - 1} remaining)`);
+            w.cleanedUp = true;
             w.child.removeAllListeners("message");
             w.child.removeAllListeners("exit");
+            w.child.removeAllListeners("error");
+            const pid = w.child.pid;
             try {
                 w.child.kill("SIGTERM");
             }
             catch (_a) { }
             this.workers = this.workers.filter((x) => x !== w);
+            // SIGTERM is ignored by a worker stuck inside a native ONNX matmul
+            // tight loop. Escalate to SIGKILL if the process is still alive after
+            // the grace period. Rare; warn-level so it's visible if it fires.
+            if (pid !== undefined) {
+                setTimeout(() => {
+                    try {
+                        process.kill(pid, 0);
+                        (0, logger_1.log)("pool", `reap escalation: SIGTERM ignored by PID:${pid}, sending SIGKILL`);
+                        try {
+                            process.kill(pid, "SIGKILL");
+                        }
+                        catch (_a) { }
+                    }
+                    catch (_b) {
+                        // ESRCH — process already gone, nothing to do.
+                    }
+                }, REAP_FORCE_KILL_GRACE_MS);
+            }
         });
     }
     destroy() {
@@ -449,8 +496,10 @@ class WorkerPool {
             this.taskQueue = [];
             this.priorityQueue = [];
             const killPromises = this.workers.map((w) => new Promise((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(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.16.10",
+  "version": "0.17.1",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -26,6 +26,8 @@
     "benchmark:index": "./run-benchmark.sh $HOME/gmax-benchmarks --index",
     "benchmark:agent": "npx tsx src/bench/benchmark-agent.ts",
     "benchmark:chart": "npx tsx src/bench/generate-benchmark-chart.ts",
+    "bench:recall": "npx tsx src/eval.ts",
+    "bench:recall:json": "GMAX_EVAL_JSON=1 npx tsx src/eval.ts",
     "format": "biome check --write .",
     "format:check": "biome check .",
     "lint": "biome lint .",

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

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.16.10",
+  "version": "0.17.1",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",