grepmax 0.26.70 → 0.26.72

package/dist/lib/workers/embeddings/mlx-client.js

@@ -51,6 +51,8 @@ exports.validateMlxEmbeddingResponse = validateMlxEmbeddingResponse;
 exports.requestMlxJSON = requestMlxJSON;
 exports.isMlxUp = isMlxUp;
 exports.mlxEmbed = mlxEmbed;
+exports.isMlxExistingReady = isMlxExistingReady;
+exports.mlxEmbedExisting = mlxEmbedExisting;
 const http = __importStar(require("node:http"));
 const logger_1 = require("../../utils/logger");
 const MLX_PORT = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
@@ -267,3 +269,28 @@ function mlxEmbed(texts, options) {
         return data.vectors.map((v) => new Float32Array(v));
     });
 }
+/** Cached positive identity permits one bounded call to the existing backend.
+ * Every response verifies model/dimensions again; no polling or startup follows
+ * from an idle cache. A failed call revokes eligibility until external work
+ * confirms readiness again.
+ */
+function isMlxExistingReady(expectedModel) {
+    return mlxAvailable === true && checkedModel === expectedModel;
+}
+function mlxEmbedExisting(texts, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isMlxExistingReady(options.expectedModel))
+            throw new Error("embedding_unavailable");
+        const result = yield requestMlxJSON("/embed", {
+            texts,
+            expected_model: options.expectedModel,
+        });
+        if (!result.ok ||
+            !validateMlxEmbeddingResponse(result.data, texts.length, options.expectedModel, options.expectedDim)) {
+            mlxAvailable = false;
+            throw new Error("embedding_unavailable");
+        }
+        lastCheck = Date.now();
+        return result.data.vectors.map((v) => new Float32Array(v));
+    });
+}

package/dist/lib/workers/orchestrator.js

@@ -54,9 +54,11 @@ const chunker_1 = require("../index/chunker");
 const embedding_generation_1 = require("../index/embedding-generation");
 const embedding_reuse_1 = require("../index/embedding-reuse");
 const skeleton_1 = require("../skeleton");
+const autostart_1 = require("../utils/autostart");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
 const path_containment_1 = require("../utils/path-containment");
+const resource_budget_1 = require("../utils/resource-budget");
 const colbert_math_1 = require("./colbert-math");
 const embedding_error_1 = require("./embedding-error");
 const colbert_1 = require("./embeddings/colbert");
@@ -323,20 +325,56 @@ class WorkerOrchestrator {
                 : { vectors, hash, mtimeMs, size };
         });
     }
-    encodeQuery(text) {
-        return __awaiter(this, void 0, void 0, function* () {
+    isExistingQueryReady() {
+        return this.embedMode === "cpu"
+            ? this.granite.isReady()
+            : (0, mlx_client_1.isMlxExistingReady)(this.generation.mlxModel);
+    }
+    encodeQuery(text_1) {
+        return __awaiter(this, arguments, void 0, function* (text, existingOnly = false, expectedGeneration) {
             var _a;
-            yield this.ensureReady();
+            if (existingOnly) {
+                if (expectedGeneration !== this.generation.fingerprint)
+                    throw Object.assign(new Error("embedding_mismatch"), {
+                        code: "embedding_mismatch",
+                    });
+                try {
+                    if ((0, autostart_1.daemonStartDeniedReason)())
+                        throw new Error();
+                    resource_budget_1.resourceBudget.checkExisting();
+                    if ((0, autostart_1.daemonStartDeniedReason)())
+                        throw new Error();
+                }
+                catch (_b) {
+                    throw Object.assign(new Error("host_pressure"), {
+                        code: "host_pressure",
+                    });
+                }
+                if (!this.isExistingQueryReady())
+                    throw new Error("embedding_unavailable");
+            }
+            else
+                yield this.ensureReady();
             // Try MLX GPU server first, fall back to ONNX CPU
-            const mlxResult = yield (0, mlx_client_1.mlxEmbed)([text], {
-                mode: this.embedMode,
-                expectedModel: this.generation.mlxModel,
-                expectedDim: this.generation.vectorDim,
-            });
+            const mlxResult = existingOnly
+                ? this.embedMode === "gpu"
+                    ? yield (0, mlx_client_1.mlxEmbedExisting)([text], {
+                        mode: this.embedMode,
+                        expectedModel: this.generation.mlxModel,
+                        expectedDim: this.generation.vectorDim,
+                    })
+                    : null
+                : yield (0, mlx_client_1.mlxEmbed)([text], {
+                    mode: this.embedMode,
+                    expectedModel: this.generation.mlxModel,
+                    expectedDim: this.generation.vectorDim,
+                });
             if (!mlxResult && !this.allowOnnxFallback) {
                 throw new Error(`MLX embedding model ${this.generation.mlxModel} is unavailable; ONNX fallback is disabled for this custom embedding generation`);
             }
-            const denseVector = (_a = mlxResult === null || mlxResult === void 0 ? void 0 : mlxResult[0]) !== null && _a !== void 0 ? _a : (yield this.granite.runBatch([text]))[0];
+            const denseVector = (_a = mlxResult === null || mlxResult === void 0 ? void 0 : mlxResult[0]) !== null && _a !== void 0 ? _a : (yield this.granite.runBatch([text], existingOnly))[0];
+            if (existingOnly)
+                return { dense: Array.from(denseVector), colbert: [], colbertDim: 0 };
             const encoded = yield this.colbert.encodeQuery(text);
             const feeds = {
                 input_ids: new ort.Tensor("int64", encoded.input_ids, [

package/dist/lib/workers/pool.js

@@ -42,7 +42,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerPool = void 0;
+exports.WorkerPool = exports.EXISTING_QUERY_QUEUE_LIMIT = exports.EXISTING_QUERY_WAIT_MS = void 0;
 exports.embeddingEnv = embeddingEnv;
 exports.getWorkerPool = getWorkerPool;
 exports.destroyWorkerPool = destroyWorkerPool;
@@ -63,6 +63,9 @@ const kernel_zone_1 = require("../utils/kernel-zone");
 const logger_1 = require("../utils/logger");
 const resource_budget_1 = require("../utils/resource-budget");
 const safety_latch_1 = require("../utils/safety-latch");
+exports.EXISTING_QUERY_WAIT_MS = 2000;
+exports.EXISTING_QUERY_QUEUE_LIMIT = 4;
+const EXISTING_QUERY_DEADLINE_MS = 10000;
 const TASK_TIMEOUT_MS = (() => {
     var _a;
     const fromEnv = Number.parseInt((_a = process.env.GMAX_WORKER_TASK_TIMEOUT_MS) !== null && _a !== void 0 ? _a : "", 10);
@@ -122,6 +125,8 @@ class ProcessWorker {
         this.modulePath = modulePath;
         this.execArgv = execArgv;
         this.busy = false;
+        this.queryReady = false;
+        this.suppressReplacement = false;
         this.pendingTaskId = null;
         this.lastBusyTime = Date.now();
         // Wall-clock at which this worker became busy with its current task; null
@@ -247,6 +252,9 @@ class WorkerPool {
         this.priorityQueue = [];
         this.taskQueue = [];
         this.tasks = new Map();
+        // Separate from ordinary queues: these requests must never trigger expansion.
+        this.existingWaiters = new Map();
+        this.existingBurst = 0;
         this.nextId = 1;
         this.destroyed = false;
         this.destroyPromise = null;
@@ -296,6 +304,10 @@ class WorkerPool {
             : [{ pid: worker.child.pid, rssBytes: worker.lastRssBytes }]);
     }
     clearTaskTimeout(task) {
+        if (task.waitTimeout) {
+            clearTimeout(task.waitTimeout);
+            task.waitTimeout = undefined;
+        }
         if (task.timeout) {
             clearTimeout(task.timeout);
             task.timeout = undefined;
@@ -350,6 +362,7 @@ class WorkerPool {
             task.abortListener = undefined;
         }
         this.tasks.delete(task.id);
+        this.existingWaiters.delete(task.id);
         this.removeFromQueue(task.id);
         if (worker) {
             worker.busy = false;
@@ -383,7 +396,8 @@ class WorkerPool {
         if (!this.destroyed) {
             // Only respawn if we have no workers left or there are pending tasks
             const hasPendingTasks = this.hasUnassignedTasks();
-            if (this.workers.length === 0 || hasPendingTasks) {
+            if ((!worker.suppressReplacement && this.workers.length === 0) ||
+                hasPendingTasks) {
                 this.maybeRespawn(reason, hasPendingTasks);
             }
             this.dispatch();
@@ -467,12 +481,16 @@ class WorkerPool {
         const onMessage = (msg) => {
             var _a, _b, _c, _d;
             var _e, _f, _g, _h;
+            if (typeof msg.queryReady === "boolean")
+                worker.queryReady = msg.queryReady;
             if (typeof msg.rss === "number")
                 worker.lastRssBytes = msg.rss;
             const task = this.tasks.get(msg.id);
             if (!task)
                 return;
             if ("heartbeat" in msg) {
+                if (task.existingOnly)
+                    return;
                 // Reset only the no-progress timeout. The hard deadline is left
                 // untouched on purpose — heartbeats must not be able to extend a task
                 // past its absolute ceiling.
@@ -610,19 +628,25 @@ class WorkerPool {
         if (this.destroyed)
             return;
         if (this.spawnDeniedReason) {
+            this.rejectExistingWaiters("host_pressure");
             this.rejectUnassignedTasks(this.spawnDeniedReason, "HOST_SAFETY");
             return;
         }
         // Work admitted before another process quarantines the host may still
         // be queued. Do not send it to an existing worker after that stop.
         try {
+            this.dispatchExistingWaiters();
+            if (this.destroyed)
+                return;
             const quarantine = (0, autostart_1.daemonStartDeniedReason)();
             if (quarantine) {
+                this.rejectExistingWaiters("host_pressure");
                 this.denySpawn(quarantine, false);
                 return;
             }
         }
         catch (_f) {
+            this.rejectExistingWaiters("host_pressure");
             this.denySpawn("quarantine check failed");
             return;
         }
@@ -673,6 +697,8 @@ class WorkerPool {
                 : "aggregate resource admission unavailable");
             return;
         }
+        idle.suppressReplacement = false;
+        this.existingBurst = 0;
         idle.busy = true;
         idle.pendingTaskId = task.id;
         idle.busySince = Date.now();
@@ -744,6 +770,165 @@ class WorkerPool {
     processFile(input, signal) {
         return this.enqueue("processFile", input, signal);
     }
+    existingWorkerState() {
+        if (this.destroyed || this.spawnDeniedReason || (0, autostart_1.daemonStartDeniedReason)())
+            return "host_pressure";
+        const warm = this.workers.filter((w) => w.queryReady && !w.cleanedUp && w.child.connected !== false);
+        return warm.some((w) => !w.busy)
+            ? "ready"
+            : warm.length
+                ? "busy"
+                : "embedding_unavailable";
+    }
+    /** Admission readiness includes a short bounded wait for an already-warm worker. */
+    existingQueryState() {
+        const state = this.existingWorkerState();
+        return state === "busy" &&
+            this.existingWaiters.size < exports.EXISTING_QUERY_QUEUE_LIMIT
+            ? "ready"
+            : this.existingWaiters.size >= exports.EXISTING_QUERY_QUEUE_LIMIT &&
+                state === "ready"
+                ? "busy"
+                : state;
+    }
+    rejectExistingWaiters(state) {
+        for (const task of this.existingWaiters.values()) {
+            task.reject(Object.assign(new Error(state), { code: state }));
+            this.completeTask(task, null);
+        }
+    }
+    dispatchExistingWaiters() {
+        while (this.existingWaiters.size) {
+            const state = this.existingWorkerState();
+            if (state === "host_pressure" || state === "embedding_unavailable") {
+                this.rejectExistingWaiters(state);
+                return;
+            }
+            // A continuous caller stream cannot keep indexing behind this queue.
+            if (this.existingBurst >= exports.EXISTING_QUERY_QUEUE_LIMIT &&
+                [...this.tasks.values()].some((t) => !t.worker && !t.existingOnly))
+                return;
+            if (state === "busy")
+                return;
+            const task = this.existingWaiters.values().next().value;
+            const age = Date.now() - task.queuedAt;
+            if (age < 0 || age >= exports.EXISTING_QUERY_WAIT_MS) {
+                task.reject(Object.assign(new Error("busy"), { code: "busy" }));
+                this.completeTask(task, null);
+                continue;
+            }
+            // The worker wait ends here; synchronous admission has its own bound and
+            // the request's overall timer/signal still applies during inference.
+            if (task.waitTimeout)
+                clearTimeout(task.waitTimeout);
+            task.waitTimeout = undefined;
+            try {
+                resource_budget_1.resourceBudget.checkExisting();
+            }
+            catch (_a) {
+                this.rejectExistingWaiters("host_pressure");
+                // Ordinary work performs its own admission; a document refusal must
+                // not strand that queue. The dispatcher rechecks containment next.
+                return;
+            }
+            // Cancellation during admission may have removed this waiter.
+            if (!this.existingWaiters.has(task.id))
+                continue;
+            const admittedAge = Date.now() - task.queuedAt;
+            if (admittedAge < 0 || admittedAge >= EXISTING_QUERY_DEADLINE_MS) {
+                task.reject(new Error("timeout"));
+                this.completeTask(task, null);
+                continue;
+            }
+            const after = this.existingWorkerState();
+            if (after !== "ready") {
+                if (after === "busy") {
+                    task.reject(Object.assign(new Error("busy"), { code: "busy" }));
+                    this.completeTask(task, null);
+                    continue;
+                }
+                this.rejectExistingWaiters(after);
+                return;
+            }
+            const worker = this.workers.find((w) => w.queryReady &&
+                !w.busy &&
+                !w.cleanedUp &&
+                w.child.connected !== false);
+            this.existingWaiters.delete(task.id);
+            if (task.waitTimeout)
+                clearTimeout(task.waitTimeout);
+            task.waitTimeout = undefined;
+            task.worker = worker;
+            task.startTime = Date.now();
+            worker.busy = true;
+            worker.suppressReplacement = true;
+            worker.busySince = Date.now();
+            worker.pendingTaskId = task.id;
+            this.tasks.set(task.id, task);
+            this.existingBurst++;
+            try {
+                worker.child.send({
+                    id: task.id,
+                    method: task.method,
+                    payload: task.payload,
+                });
+            }
+            catch (_b) {
+                this.completeTask(task, worker);
+                worker.queryReady = false;
+                task.reject(new Error("embedding_unavailable"));
+            }
+        }
+    }
+    encodeQueryExisting(text, signal) {
+        const state = this.existingQueryState();
+        if (state !== "ready")
+            return Promise.reject(Object.assign(new Error(state), { code: state }));
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return Promise.reject(Object.assign(new Error("Aborted"), { name: "AbortError" }));
+        return new Promise((resolve, reject) => {
+            const id = this.nextId++;
+            const task = {
+                id,
+                method: "encodeQuery",
+                payload: {
+                    text,
+                    existingOnly: true,
+                    generation: this.generation.fingerprint,
+                },
+                resolve,
+                reject,
+                queuedAt: Date.now(),
+                signal,
+                existingOnly: true,
+            };
+            const cancel = () => {
+                task.callerAborted = true;
+                reject(Object.assign(new Error("Aborted"), { name: "AbortError" }));
+                if (!task.worker) {
+                    this.completeTask(task, null);
+                    this.dispatch();
+                }
+            };
+            task.abortListener = cancel;
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", cancel, { once: true });
+            // Caller deadline does not kill or replace this shared worker. Its bounded
+            // inference settles lifecycle independently, just like normal cancellation.
+            task.timeout = setTimeout(() => {
+                task.callerAborted = true;
+                reject(new Error("timeout"));
+                if (!task.worker)
+                    this.completeTask(task, null);
+            }, EXISTING_QUERY_DEADLINE_MS);
+            task.waitTimeout = setTimeout(() => {
+                reject(Object.assign(new Error("busy"), { code: "busy" }));
+                this.completeTask(task, null);
+                this.dispatch();
+            }, exports.EXISTING_QUERY_WAIT_MS);
+            this.existingWaiters.set(id, task);
+            this.dispatch();
+        });
+    }
     encodeQuery(text, signal) {
         return this.enqueue("encodeQuery", { text }, signal);
     }
@@ -826,7 +1011,7 @@ class WorkerPool {
      * floor with a fresh, lean worker. Shared by the idle and post-task RSS paths.
      */
     recycleWorker(w, reason) {
-        if (w.cleanedUp)
+        if (w.cleanedUp || w.busy)
             return;
         (0, logger_1.log)("pool", `recycle bloated worker PID:${w.child.pid} (${reason}, rss ${Math.round(w.lastRssBytes / 1048576)}MB > ${WORKER_RSS_RECYCLE_MB}MB)`);
         w.cleanedUp = true;
@@ -856,7 +1041,9 @@ class WorkerPool {
             }, REAP_FORCE_KILL_GRACE_MS);
         }
         // Replace anything we dropped below the floor with fresh, lean workers.
-        while (!this.destroyed && this.workers.length < MIN_KEEP_WORKERS) {
+        while (!w.suppressReplacement &&
+            !this.destroyed &&
+            this.workers.length < MIN_KEEP_WORKERS) {
             if (!this.spawnWorker())
                 break;
         }
@@ -924,6 +1111,7 @@ class WorkerPool {
                 this.idleReapInterval = null;
             }
             this.clearScaleUpTimer();
+            this.rejectExistingWaiters("embedding_unavailable");
             for (const task of this.tasks.values()) {
                 task.reject(new Error("Worker pool destroyed"));
                 this.completeTask(task, null);

package/dist/lib/workers/process-child.js

@@ -59,11 +59,14 @@ const send = (msg) => {
     if (node_process_1.default.send) {
         // Attach current RSS so the pool can recycle workers whose native (ONNX)
         // memory has ballooned — the V8 --max-old-space-size cap can't see it.
-        node_process_1.default.send(Object.assign(Object.assign({}, msg), { rss: node_process_1.default.memoryUsage().rss }));
+        node_process_1.default.send(Object.assign(Object.assign({}, msg), { rss: node_process_1.default.memoryUsage().rss, queryReady: (0, worker_1.isExistingQueryReady)() }));
     }
 };
+let restrictedInFlight = false;
 const handleMessage = (msg) => __awaiter(void 0, void 0, void 0, function* () {
     const { id, method, payload } = msg;
+    restrictedInFlight =
+        method === "encodeQuery" && payload.existingOnly === true;
     const start = performance.now();
     (0, logger_1.debug)("worker", `recv task=${id} method=${method}${method === "processFile" ? ` file=${payload.path}` : ""}`);
     try {
@@ -91,23 +94,37 @@ const handleMessage = (msg) => __awaiter(void 0, void 0, void 0, function* () {
         send({ id, error: `Unknown method: ${method}` });
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+        const rawCode = err === null || err === void 0 ? void 0 : err.code;
+        const safeCode = typeof rawCode === "string" &&
+            ["host_pressure", "embedding_mismatch", "embedding_unavailable"].includes(rawCode)
+            ? rawCode
+            : "embedding_unavailable";
+        const message = restrictedInFlight
+            ? safeCode
+            : err instanceof Error
+                ? err.message
+                : String(err);
         (0, logger_1.debug)("worker", `fail task=${id} method=${method} ${(performance.now() - start).toFixed(0)}ms: ${message}`);
-        const code = err === null || err === void 0 ? void 0 : err.code;
+        const code = restrictedInFlight
+            ? safeCode
+            : err === null || err === void 0 ? void 0 : err.code;
         send(Object.assign({ id, error: message }, (typeof code === "string" ? { code } : {})));
     }
+    finally {
+        restrictedInFlight = false;
+    }
 });
 const handleMessageSerially = (0, serialized_handler_1.createSerializedHandler)(handleMessage);
 node_process_1.default.on("message", (msg) => {
     void handleMessageSerially(msg);
 });
 node_process_1.default.on("uncaughtException", (err) => {
-    console.error("[process-worker] uncaughtException", err);
+    console.error("[process-worker] uncaughtException", restrictedInFlight ? "restricted query failed" : err);
     node_process_1.default.exitCode = 1;
     node_process_1.default.exit();
 });
 node_process_1.default.on("unhandledRejection", (reason) => {
-    console.error("[process-worker] unhandledRejection", reason);
+    console.error("[process-worker] unhandledRejection", restrictedInFlight ? "restricted query failed" : reason);
     node_process_1.default.exitCode = 1;
     node_process_1.default.exit();
 });

package/dist/lib/workers/worker.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExistingQueryReady = void 0;
 exports.default = processFile;
 exports.encodeQuery = encodeQuery;
 exports.rerank = rerank;
@@ -33,9 +34,11 @@ function processFile(input, onProgress) {
 }
 function encodeQuery(input) {
     return __awaiter(this, void 0, void 0, function* () {
-        return orchestrator.encodeQuery(input.text);
+        return orchestrator.encodeQuery(input.text, input.existingOnly, input.generation);
     });
 }
+const isExistingQueryReady = () => orchestrator.isExistingQueryReady();
+exports.isExistingQueryReady = isExistingQueryReady;
 function rerank(input) {
     return __awaiter(this, void 0, void 0, function* () {
         return orchestrator.rerank(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.70",
+  "version": "0.26.72",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -46,7 +46,8 @@
     "postversion": "bash scripts/postrelease.sh",
     "audit:consumer": "node scripts/audit-consumer.cjs",
     "audit:python": "python3 scripts/audit-python.py && python3 scripts/audit-python.py --lockfile lance-maintenance/uv.lock",
-    "test:python": "python3 -m unittest discover -s tests/python"
+    "test:python": "python3 -m unittest discover -s tests/python",
+    "audit:document-search": "node scripts/audit-document-search.cjs"
   },
   "keywords": [
     "grepmax",
@@ -79,7 +80,8 @@
     "lance-maintenance/uv.lock",
     "README.md",
     "LICENSE",
-    "NOTICE"
+    "NOTICE",
+    "DOCUMENT-SEARCH.md"
   ],
   "license": "Apache-2.0",
   "description": "Semantic code search for coding agents. Local embeddings, call graph tracing, compact code context.",

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

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