grepmax 0.26.71 → 0.26.72

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.71",
+      "version": "0.26.72",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/DOCUMENT-SEARCH.md

@@ -63,16 +63,37 @@ confirmation of the existing configured MLX model. Idle time alone does not revo
 that identity: each bounded `/embed` response revalidates model and dimensions,
 and successful inference renews the normal health cache. Failure revokes restricted
 eligibility until external work confirms readiness. A worker rechecks before inference;
-no initialization, health polling, retry or backend fallback is allowed. Cold or
-busy workers refuse immediately without queueing, spawning or scaling.
+no initialization, health polling, retry or backend fallback is allowed. Cold
+workers refuse immediately. When compatible warm workers are occupied, at most
+four document queries may wait FIFO for up to two seconds for a warm worker.
+They get a turn between indexing files; after four consecutive document-query
+assignments, waiting ordinary work gets a turn. A full queue or expired worker
+wait returns `busy`. `queryState: ready` describes admission availability, including
+this bounded wait, and does not guarantee immediate execution or query success.
+Waiting requests live outside the ordinary worker queues and cannot trigger
+worker startup, replacement or scaling. Existing ordinary work retains its own
+admitted lifecycle, including independent expansion/replacement.
 
-Read-only admission samples existing host/ledger state without creating locks,
-reservations, pruning records or changing containment markers. Existing Darwin
-inference requires known-normal aggregate resources even if ordinary expansion
-uses a looser policy. Other platforms retain the existing no-footprint-probe
-policy; this is not a cross-platform native qualification claim.
-An absent ledger in a fresh `critical-only` home is sampled as empty without being
-created; existing corrupt or symlinked ledgers still refuse. Markdown coverage
+Admission and warm readiness are rechecked when a worker becomes available.
+Queued cancellation/deadlines withdraw the request; cancellation after dispatch
+keeps the shared worker assigned until its actual terminal response or exit.
+The ten-second request bound includes waiting rather than restarting at dispatch.
+Synchronous admission has its own probe bound and is checked against the absolute
+request deadline before any query is sent. Native retrieval still uses the
+remaining overall deadline. An in-flight indexing file is never interrupted;
+long files or backend outages can still exceed the worker wait and return `busy`.
+
+Read-only admission honors the configured host guard policy without creating locks,
+reservations, pruning records or changing containment markers. Under the default
+`strict` policy, existing Darwin inference requires fresh known-normal aggregate
+resources and reads the existing ledger; absent ledgers are treated as empty and
+corrupt or symlinked ledgers refuse. Explicit `critical-only` uses fresh OS/kernel
+pressure probes without aggregate sampling or ledger access: warning/unknown
+measurements remain diagnostic, while confirmed critical pressure refuses.
+Containment is checked before and after sampling in either policy. This read-only
+path never creates a safety latch; the daemon's safety machinery remains authoritative.
+Other platforms retain the existing no-footprint-probe policy; this is not a
+cross-platform native qualification claim. Markdown coverage
 and returned pointers require regular files, including after symlink resolution;
 a directory whose name ends in `.md` can be a prefix but never a source pointer.
 

package/README.md

@@ -241,6 +241,19 @@ index and already-warm compatible query worker. It cannot start a daemon, watch
 project, initialize a model, fall back to another backend or mutate the index.
 Cold, busy or unavailable resources return an explicit unavailable state.
 
+Document query admission follows the configured host guard policy. On macOS,
+default `strict` requires fresh aggregate resource admission; explicit
+`critical-only` checks OS/kernel critical pressure without an aggregate scan or
+ledger access. Warning or unavailable measurements stay diagnostic in that mode.
+Both policies preserve containment checks. Up to four document queries can wait
+FIFO for an already-warm compatible worker for up to two seconds, taking a turn
+between indexing files. After four consecutive document queries, waiting ordinary
+work gets a turn. Saturation or wait expiry returns `busy`; cold workers still
+refuse. This wait cannot start, replace or scale workers, and it never interrupts
+an in-flight file. Admission/readiness are checked again before dispatch, and the
+overall ten-second deadline includes waiting. Readiness means a request can be
+admitted, including this bounded wait. Long indexing files can still return `busy`.
+
 Results contain canonical paths and one-based source ranges, without cached source
 bodies. The first slice uses dense retrieval with explicit path scope and bounded
 deadlines. Consumers must reread and authorize current source before using a
@@ -594,6 +607,75 @@ The candidate trace contains pointers and stage ranks for at most the first 200
 
 Each traced candidate also has an `outcome`: returned, stage-one/pooled cut, deduplicated, per-file limit or display limit. Display limit means the production loop filled its result window before examining that candidate; it does not assert that the candidate would pass the per-file cap.
 
+#### Existing-index document retrieval evaluation
+
+In a source checkout, [scripts/eval-documents.cjs](scripts/eval-documents.cjs) measures the released [document MCP contract](DOCUMENT-SEARCH.md) through an explicit installed entry point. It uses only Node built-ins and sequential `document_search_status` / `semantic_search` calls. It performs no model warmup, daemon startup, indexing, refusal retries or fallback to normal hybrid search.
+
+```bash
+node scripts/eval-documents.cjs \
+  --fixture docs/measurements/documents/fixture-v1.json \
+  --sha256 <reviewed-fixture-digest> \
+  --root /absolute/already-indexed/project \
+  --entry /absolute/installed/grepmax/dist/bin.js \
+  --output docs/measurements/documents/baseline-v1.json
+```
+
+Freeze the JSON fixture before retrieving results. It contains `schemaVersion: 1`, `purpose`, explicit project-relative `prefixes`, and 1–100 `cases`. Each case has a unique `id`, a `query` (maximum 500 characters), and one or more `expected` targets: `{file, startLine, endLine, sourceSha256}`. Files are contained relative Markdown paths; ranges are one-based and answer-bearing; hashes cover exact source bytes. Keep private fixtures and evidence in ignored `docs/measurements/`. Optional `--repeats 1-3` repeats the same frozen cases without retries or warmup.
+
+The report separates the rank of the expected document among distinct returned documents from the rank of an overlapping expected section among chunk pointers. Document Recall@10 credits the fraction of declared target documents retrieved; MRR@10 credits only ranks 1–10. Section overlap indicates source-context discovery, not complete answer coverage. Only the first 50 returned candidates are available; document deduplication cannot recover targets outside that window. Reviewed targets are not exhaustive judgments of all useful documents, so these metrics describe the frozen targets, not general recall.
+
+Source and indexed hashes must match the fixture before querying; generation and project/store identity must agree across coverage and retrieval. Returned source ranges require reread/hash verification; new artifacts retain both the indexed pointer digest and current-source digest so later reviews can check provenance. Refusals, changed targets and unverified expected pointers are excluded from relevance metrics and counted separately; `usableFraction` includes every planned sample. Background indexing and partial/degraded index context are recorded without excluding targets whose coverage and hashes remain current. No queries, source bodies or raw diagnostics are copied into result artifacts. Reads are bounded to 2 MiB per source; MCP frames to 1 MiB. The report and sibling `.samples.jsonl` checkpoint refuse overwrite and use owner-only permissions. Exit 0 means an evaluation with usable samples completed, not that a quality threshold passed; exit 2 means no usable samples; exit 1 means preflight or transport/contract failure. No consumer rollout is implied.
+
+To investigate scope competition, [scripts/eval-document-scopes.cjs](scripts/eval-document-scopes.cjs) compares the original fixture prefixes against declared narrower directories without changing queries or targets:
+
+```bash
+node scripts/eval-document-scopes.cjs \
+  --fixture docs/measurements/documents/fixture-v1.json --sha256 <digest> \
+  --root /absolute/already-indexed/project \
+  --entry /absolute/installed/grepmax/dist/bin.js \
+  --output docs/measurements/documents/paired-scope-v1.json \
+  --narrow-prefix docs/services --narrow-prefix docs/modules
+```
+
+Declare and freeze the scope hypothesis before querying. Narrower prefixes must stay within the original scope and retain every target. Arm order alternates per case, with a one-second gap between pairs and no retries. Reports show each arm's standalone observations and separately compare only pairs where both arms are usable under the same resource generation, project and store. The live competing corpus can still change; this is a diagnostic comparison rather than an isolated causal test. Scopes chosen from known target families introduce a useful prior, so gains do not establish unscoped or held-out retrieval quality. Owner-only checkpoints, overwrite refusal and source/transport bounds are shared with the base evaluator. Exit 2 means no comparable pairs.
+
+### Offline lexical candidate experiment
+
+[scripts/eval-document-lexical.cjs](scripts/eval-document-lexical.cjs) tests lexical candidates and fixed document reciprocal-rank fusion against a prior paired scope report. It uses Node built-ins and filesystem Markdown only; it never contacts a daemon, opens a native store, loads a model or changes production retrieval.
+
+Freeze an owner-only study plan before scoring, including the original fixture checksum, archived report checksum, canonical root, narrower relative prefixes, fixed algorithm parameters and resource limits. The selected scope must retain every target and match the archived narrow arm. Pass that plan's checksum explicitly:
+
+```bash
+NODE_OPTIONS=--max-old-space-size=384 node scripts/eval-document-lexical.cjs \
+  --fixture docs/measurements/documents/fixture-v1.json \
+  --plan docs/measurements/documents/lexical-plan.json --plan-sha256 <digest> \
+  --archive docs/measurements/documents/paired-scope-v1.json \
+  --snapshot docs/measurements/documents/new-private-snapshot \
+  --output docs/measurements/documents/new-lexical-report.json
+```
+
+The prototype uses fixed 48-line windows with eight-line overlap, BM25 `k1=1.2` / `b=0.75`, 50 positive-score lexical candidates and equal-weight document RRF with constant 60. Targets are used for grading only. Stable path/line ties, no per-case overrides and no zero-score padding keep the experiment reproducible. Bounds are 512 files, 16 MiB total source, 2 MiB per file, 10,000 windows, one million token occurrences and 20,000 directory entries. Missing, aliased, changed or oversized source fails snapshot creation rather than silently dropping competing documents. A private snapshot preserves exact source bytes and a digest manifest; the report stores pointers, digests, IDs and scores without questions or source bodies. Existing output/snapshot paths are refused.
+
+Lexical metrics cover cases whose frozen targets match the snapshot. Archive replay additionally requires original ready state/resource identity and every competitor pointer's indexed/current digest and range to match the snapshot; an invalid competitor excludes the entire case. Refused archive cases stay separate. Offline lexical availability does not exercise deployed busy/pressure admission. Archived dense candidates are not re-encoded over this snapshot, and narrower families chosen from known target locations introduce a prior. Report document gains/losses on the verified shared replay cohort; section overlap is diagnostic because window sizes and hybrid representatives differ from production chunks. A passing exploratory gate only supports proposing further matched qualification. No production integration or rollout follows automatically. Exit 0 means scoring completed with usable lexical cases, even when the gate fails; exit 2 means no usable lexical cases, and exit 1 means preflight or evaluation failure.
+
+### Protected document fusion qualification
+
+[scripts/eval-document-fusion.cjs](scripts/eval-document-fusion.cjs) qualifies a fixed candidate ordering in two modes: replay cached verified lexical/dense candidates, or collect one broader pass through the released existing-only MCP. It interleaves each arm's first three distinct documents (`lex1,dense1,lex2,dense2,lex3,dense3`), deduplicates while preserving the selected arm's pointer, then fills to 50 with the fixed RRF tail. This protects high-ranked lexical-only evidence; spending up to six slots can displace useful lower-ranked dense candidates. Expected targets never affect ranking.
+
+```bash
+NODE_OPTIONS=--max-old-space-size=384 node scripts/eval-document-fusion.cjs \
+  --mode live --design <frozen-design.json> --design-sha256 <digest> \
+  --fixture <frozen-fixture.json> --fixture-sha256 <digest> \
+  --entry /absolute/path/to/installed/grepmax/dist/bin.js --entry-sha256 <digest> \
+  --snapshot <new-private-snapshot-directory> --output <new-private-report.json>
+```
+
+For `--mode replay`, replace the entry arguments with `--input <prior-lexical-report.json> --input-sha256 <digest>` and point `--snapshot` at its immutable snapshot. Replay uses saved lexical candidates without rescoring queries. Live mode snapshots the complete predefined scope and builds the bounded filesystem index before MCP initialization; it permits one case-order pass with one-second gaps, without retries, warmup, runtime startup or native fallback. The existing-only entry must expose the expected restricted capabilities. Coverage, generation, project/store identity and every indexed/current competitor digest and range must verify. Refusals remain separate from relevance. A final full source-byte/file-set fence invalidates comparisons if the corpus changed; checkpoints are provisional and the final JSON is authoritative.
+
+The lexical CLI retains its one-million-token default. A frozen fusion design may explicitly allow 1,100,000 token occurrences; all other source/window limits and the 384 MiB Node heap setting remain unchanged. The heap setting is not an operating-system physical memory cap. Outputs and snapshots refuse overwrite and use private permissions; reports exclude question text and source bodies. The broader study requires at least 16 of 20 comparable cases, no dense top-ten target losses, and protected document recall at least as high as either arm on the same cohort. Other predefined positive cohort bounds are supported. Exit 0 means collection completed with some comparable cases, even if the gate fails; exit 2 means none, and exit 1 means interrupted/preflight failure.
+
+The October 8 experiment recovered both original residuals: Redis rank 1, People rank 3, 15/15 replay document hits with no dense top-ten target loss. Its broader 393-file, 20-case pass produced only two comparable cases (15 busy and three pressure refusals; one busy case also lacked indexed coverage), below the frozen 16-case minimum. Broader qualification is **insufficient**. Questions were source-curated after the rule freeze and held out from parameter selection, not independently adjudicated real-user questions. Representative/window differences prevent like-for-like section accuracy claims. This evaluation does not change production retrieval or authorize integration, release or rollout.
+
 ## Attribution
 
 grepmax is built upon the foundation of [mgrep](https://github.com/mixedbread-ai/mgrep) by MixedBread. See the [NOTICE](NOTICE) file for details.

package/dist/lib/utils/resource-budget.js

@@ -323,12 +323,22 @@ class ResourceBudget {
             },
         };
     }
-    /** Read-only admission for existing inference. Never seed/lock/prune the ledger or latch. */
+    /** Read-only admission for existing inference, honoring the selected host policy.
+     * Never seed/lock/prune the ledger or latch. */
     checkExisting() {
         if (this.deps.quarantine())
             throw new ResourceAdmissionError("host containment");
         if (this.deps.platform !== "darwin")
             return null;
+        if (this.deps.policy() === "critical-only") {
+            const snapshot = this.deps.criticalSample();
+            if (snapshot.memoryPressure === "critical" ||
+                snapshot.kernelPressure === "critical")
+                throw new ResourceAdmissionError("critical host pressure; existing inference refused", true);
+            if (this.deps.quarantine())
+                throw new ResourceAdmissionError("host containment");
+            return snapshot;
+        }
         const records = this.readExistingRecords();
         const snapshot = this.deps.sample();
         assertResourceSnapshot(snapshot, this.charge(snapshot, records), resolveResourceBudgetMb(), this.deps.now(), this.deps.sampleMaxAgeMs);

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);
@@ -249,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;
@@ -298,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;
@@ -352,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;
@@ -617,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;
         }
@@ -681,6 +698,7 @@ class WorkerPool {
             return;
         }
         idle.suppressReplacement = false;
+        this.existingBurst = 0;
         idle.busy = true;
         idle.pendingTaskId = task.id;
         idle.busySince = Date.now();
@@ -752,8 +770,7 @@ class WorkerPool {
     processFile(input, signal) {
         return this.enqueue("processFile", input, signal);
     }
-    /** No queue, scaling or initialization for an existing-index document query. */
-    existingQueryState() {
+    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);
@@ -763,23 +780,112 @@ class WorkerPool {
                 ? "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" }));
-        try {
-            resource_budget_1.resourceBudget.checkExisting();
-        }
-        catch (_a) {
-            return Promise.reject(Object.assign(new Error("host_pressure"), { code: "host_pressure" }));
-        }
-        // Recheck after admission: quarantine or worker readiness may have changed.
-        const after = this.existingQueryState();
-        if (after !== "ready")
-            return Promise.reject(Object.assign(new Error(after), { code: after }));
-        const worker = this.workers.find((w) => w.queryReady && !w.busy && !w.cleanedUp && w.child.connected !== false);
         return new Promise((resolve, reject) => {
             const id = this.nextId++;
             const task = {
@@ -795,11 +901,14 @@ class WorkerPool {
                 queuedAt: Date.now(),
                 signal,
                 existingOnly: true,
-                worker,
             };
             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 });
@@ -808,20 +917,16 @@ class WorkerPool {
             task.timeout = setTimeout(() => {
                 task.callerAborted = true;
                 reject(new Error("timeout"));
-            }, 10000);
-            worker.busy = true;
-            worker.suppressReplacement = true;
-            worker.busySince = Date.now();
-            worker.pendingTaskId = id;
-            this.tasks.set(id, task);
-            try {
-                worker.child.send({ id, method: task.method, payload: task.payload });
-            }
-            catch (_a) {
-                this.completeTask(task, worker);
-                worker.queryReady = false;
-                reject(new Error("embedding_unavailable"));
-            }
+                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) {
@@ -1006,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.71",
+  "version": "0.26.72",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

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

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