grepmax 0.19.0 → 0.21.0

package/dist/lib/index/syncer.js

@@ -74,13 +74,24 @@ function flushBatch(db, meta, vectors, pendingMeta, pendingDeletes, dryRun) {
     return __awaiter(this, void 0, void 0, function* () {
         if (dryRun)
             return;
-        // 1. Write to VectorDB first (source of truth for data)
-        if (pendingDeletes.length > 0) {
-            yield db.deletePaths(pendingDeletes);
-        }
+        // 1. Insert the new vectors FIRST, then delete the old chunks for those paths
+        //    (excluding the just-inserted ids). Deleting first would leave a file
+        //    unsearchable if the insert then fails — the old, still-valid chunks would
+        //    already be gone. Mirrors batch-processor's insert-first flush. Paths in
+        //    pendingDeletes with no new vectors (emptied / non-indexable files) match
+        //    no excluded id, so all their old chunks are removed.
+        const newIds = vectors.map((v) => v.id);
         if (vectors.length > 0) {
             yield db.insertBatch(vectors);
         }
+        if (pendingDeletes.length > 0) {
+            if (newIds.length > 0) {
+                yield db.deletePathsExcludingIds(pendingDeletes, newIds);
+            }
+            else {
+                yield db.deletePaths(pendingDeletes);
+            }
+        }
         // 2. Update MetaCache only after VectorDB write succeeds
         for (const [p, entry] of pendingMeta.entries()) {
             meta.put(p, entry);

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

@@ -67,8 +67,17 @@ function processBatchCore(batch, metaCache, pool, signal) {
             }
             try {
                 const stats = yield fs.promises.stat(absPath);
-                if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
+                if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size)) {
+                    // File became non-indexable (emptied or now too large). If we indexed
+                    // it before, drop its chunks + meta so search stops returning stale
+                    // content; otherwise there's nothing to clean up.
+                    if (metaCache.get(absPath)) {
+                        deletes.push(absPath);
+                        metaDeletes.push(absPath);
+                        reindexed++;
+                    }
                     continue;
+                }
                 const cached = metaCache.get(absPath);
                 if ((0, cache_check_1.isFileCached)(cached, stats)) {
                     continue;

package/dist/lib/llm/config.js

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

package/dist/lib/llm/investigate.js

@@ -45,6 +45,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.looksLikeRawToolCall = looksLikeRawToolCall;
+exports.toolCallLeakHint = toolCallLeakHint;
+exports.finalizeAnswer = finalizeAnswer;
 exports.investigate = investigate;
 const path = __importStar(require("node:path"));
 const openai_1 = __importDefault(require("openai"));
@@ -58,6 +61,37 @@ const tools_1 = require("./tools");
 function stripThinkTags(text) {
     return text.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/g, "").trim();
 }
+/**
+ * Detect raw model tool-call markup leaking into `message.content`.
+ *
+ * Some local models (notably Qwen3.5-35B-A3B, which emits Qwen-XML tool calls)
+ * trip a known llama.cpp `peg-native` parser bug: the call is never extracted
+ * into structured `tool_calls` and instead leaks into `content` as raw markup
+ * like `<tool_call>…`, `<function=peek>…`, or `<parameter=…>`. Returning that
+ * verbatim as the "answer" is what this guards against.
+ */
+function looksLikeRawToolCall(text) {
+    return /<tool_call\b|<\/?function[=\s>]|<parameter[=\s>]/i.test(text);
+}
+/** Guidance shown when a non-tool-calling model leaks raw tool-call markup. */
+function toolCallLeakHint(modelName) {
+    return (`The investigate tool needs a model that emits structured tool calls, but ` +
+        `"${modelName}" returned raw tool-call markup instead. This is a known ` +
+        `llama.cpp limitation for Qwen-XML tool-calling models — switch GMAX_LLM_MODEL ` +
+        `to a Hermes-JSON tool-calling model (e.g. Qwen3-30B-A3B-Instruct-2507), or ` +
+        `use review_commit / the gmax CLI search tools for this question.`);
+}
+/**
+ * Turn a model message's content into the final answer: detect a tool-call leak
+ * (return a clear hint), otherwise strip reasoning tags.
+ */
+function finalizeAnswer(content, modelName) {
+    if (content && looksLikeRawToolCall(content)) {
+        return toolCallLeakHint(modelName);
+    }
+    const stripped = content ? stripThinkTags(content) : "";
+    return stripped || "(no response)";
+}
 function investigate(opts) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;
@@ -116,9 +150,7 @@ function investigate(opts) {
                     if (verbose) {
                         process.stderr.write(`[R${round}] Final answer (${roundMs}ms)\n`);
                     }
-                    const answer = message.content
-                        ? stripThinkTags(message.content)
-                        : "(no response)";
+                    const answer = finalizeAnswer(message.content, modelName);
                     return {
                         answer,
                         rounds,
@@ -194,6 +226,10 @@ function investigate(opts) {
                 process.stderr.write(`[R${maxRounds}] Round cap reached, forcing final answer\n`);
             }
             messages.push({ role: "user", content: prompts_1.FORCE_FINAL_MESSAGE });
+            // No tools on the synthesis call. Note: tool_choice:"none" does NOT stop this
+            // model from emitting a stray tool call here (verified 2026-06-28 — it still
+            // leaks raw markup into content), so the finalizeAnswer guard is what protects
+            // this path rather than a request-shape tweak.
             const response = yield client.chat.completions.create({
                 model: modelName,
                 messages,
@@ -202,9 +238,7 @@ function investigate(opts) {
             if (!((_c = response.choices) === null || _c === void 0 ? void 0 : _c.length)) {
                 throw new Error("LLM returned empty response");
             }
-            const answer = response.choices[0].message.content
-                ? stripThinkTags(response.choices[0].message.content)
-                : "(no response)";
+            const answer = finalizeAnswer(response.choices[0].message.content, modelName);
             return {
                 answer,
                 rounds: rounds + 1,

package/dist/lib/llm/server.js

@@ -143,7 +143,7 @@ class LlmServer {
                 throw new Error(`Model file not found: "${this.config.model}". Set GMAX_LLM_MODEL to a valid .gguf path`);
             }
             const logFd = (0, log_rotate_1.openRotatedLog)(config_1.PATHS.llmLogFile);
-            const child = (0, node_child_process_1.spawn)(binary, [
+            const args = [
                 "-m",
                 this.config.model,
                 "--host",
@@ -154,7 +154,14 @@ class LlmServer {
                 String(this.config.ngl),
                 "--ctx-size",
                 String(this.config.ctxSize),
-            ], { detached: true, stdio: ["ignore", logFd, logFd] });
+            ];
+            if (this.config.reasoningFormat) {
+                args.push("--reasoning-format", this.config.reasoningFormat);
+            }
+            const child = (0, node_child_process_1.spawn)(binary, args, {
+                detached: true,
+                stdio: ["ignore", logFd, logFd],
+            });
             child.unref();
             fs.closeSync(logFd);
             const pid = child.pid;

package/dist/lib/llm/tools.js

@@ -244,7 +244,7 @@ function executePeek(args, ctx) {
         const metaRows = yield table
             .query()
             .select(["is_exported", "start_line", "end_line"])
-            .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+            .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND ${(0, filter_builder_1.pathStartsWith)(prefix)}`)
             .limit(1)
             .toArray();
         const exported = metaRows.length > 0 && Boolean(metaRows[0].is_exported);

package/dist/lib/search/pagerank.js

@@ -147,7 +147,7 @@ function buildGraphFromDb(db, pathPrefix) {
         const rows = yield table
             .query()
             .select(["defined_symbols", "referenced_symbols"])
-            .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+            .where((0, filter_builder_1.pathStartsWith)(prefix))
             .toArray();
         const nodes = new Set();
         const edges = new Map();

package/dist/lib/search/searcher.js

@@ -51,7 +51,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
     var _a;
     const parts = [];
     if (pathPrefix) {
-        parts.push(`path LIKE '${(0, filter_builder_1.escapeSqlString)((0, filter_builder_1.normalizePath)(pathPrefix))}%'`);
+        parts.push((0, filter_builder_1.pathStartsWith)((0, filter_builder_1.normalizePath)(pathPrefix)));
     }
     const fileFilter = filters === null || filters === void 0 ? void 0 : filters.file;
     if (typeof fileFilter === "string" && fileFilter) {
@@ -62,7 +62,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
         const absExclude = pathPrefix
             ? (0, filter_builder_1.normalizePath)(pathPrefix + excludeFilter)
             : excludeFilter;
-        parts.push(`path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(absExclude)}%'`);
+        parts.push((0, filter_builder_1.pathNotStartsWith)(absExclude));
     }
     // New array-shape: pre-resolved absolute exclude prefixes from
     // resolveScope (or daemon IPC). Each becomes its own NOT LIKE clause.
@@ -71,7 +71,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
         for (const p of excludePrefixes) {
             if (typeof p === "string" && p) {
                 const norm = (0, filter_builder_1.normalizePath)(p);
-                parts.push(`path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(norm)}%'`);
+                parts.push((0, filter_builder_1.pathNotStartsWith)(norm));
             }
         }
     }
@@ -84,7 +84,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
         for (const p of inPrefixes) {
             if (typeof p === "string" && p) {
                 const norm = (0, filter_builder_1.normalizePath)(p);
-                clauses.push(`path LIKE '${(0, filter_builder_1.escapeSqlString)(norm)}%'`);
+                clauses.push((0, filter_builder_1.pathStartsWith)(norm));
             }
         }
         if (clauses.length === 1)
@@ -106,7 +106,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
         const roots = projectRoots.split(",");
         const clauses = roots.map((r) => {
             const prefix = r.endsWith("/") ? r : `${r}/`;
-            return `path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`;
+            return (0, filter_builder_1.pathStartsWith)(prefix);
         });
         parts.push(`(${clauses.join(" OR ")})`);
     }
@@ -114,7 +114,7 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
     if (typeof excludeRoots === "string" && excludeRoots) {
         for (const r of excludeRoots.split(",")) {
             const prefix = r.endsWith("/") ? r : `${r}/`;
-            parts.push(`path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`);
+            parts.push((0, filter_builder_1.pathNotStartsWith)(prefix));
         }
     }
     const defFilter = filters === null || filters === void 0 ? void 0 : filters.def;

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

@@ -48,6 +48,7 @@ const fs = __importStar(require("node:fs"));
 const lancedb = __importStar(require("@lancedb/lancedb"));
 const apache_arrow_1 = require("apache-arrow");
 const config_1 = require("../../config");
+const index_config_1 = require("../index/index-config");
 const cleanup_1 = require("../utils/cleanup");
 const filter_builder_1 = require("../utils/filter-builder");
 const logger_1 = require("../utils/logger");
@@ -86,7 +87,10 @@ class VectorDB {
         this.activeWrites = 0;
         this.writeDrainResolve = null;
         this.compactingPromise = null;
-        this.vectorDim = vectorDim !== null && vectorDim !== void 0 ? vectorDim : config_1.CONFIG.VECTOR_DIM;
+        // Default to the configured tier's dim (not the hard-wired small-tier 384)
+        // so a `standard`-tier index actually stores 768d vectors. An explicit
+        // arg still wins (eval scripts, tests).
+        this.vectorDim = vectorDim !== null && vectorDim !== void 0 ? vectorDim : (0, index_config_1.readGlobalConfig)().vectorDim;
         this.unregisterCleanup = (0, cleanup_1.registerCleanup)(() => this.close());
     }
     /**
@@ -275,6 +279,32 @@ class VectorDB {
             summary: "",
         };
     }
+    /**
+     * Read the physical width of the on-disk `vector` column, or null if the
+     * table doesn't exist yet. Non-throwing and validation-free on purpose: doctor
+     * uses it to detect a table stranded at an old width after a tier change, and
+     * must see the truth even when the table is incompatible with the current
+     * config (a throwing ensureTable would mask exactly the mismatch we're hunting).
+     */
+    getSchemaVectorDim() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.getDb();
+            let table;
+            try {
+                table = yield db.openTable(TABLE_NAME);
+            }
+            catch (_a) {
+                return null; // no table on disk yet
+            }
+            const schema = yield table.schema();
+            const field = schema.fields.find((f) => f.name === "vector");
+            if (!field)
+                return null;
+            // The `vector` column is a FixedSizeList; its listSize is the vector width.
+            const listSize = field.type.listSize;
+            return typeof listSize === "number" ? listSize : null;
+        });
+    }
     validateSchema(table) {
         return __awaiter(this, void 0, void 0, function* () {
             const schema = yield table.schema();
@@ -411,11 +441,15 @@ class VectorDB {
             // Callers (syncer flushBatch) splice records before passing — they're never reused.
             for (const rec of records) {
                 const vec = toNumberArray(rec.vector);
-                if (vec.length < this.vectorDim) {
-                    vec.push(...Array(this.vectorDim - vec.length).fill(0));
-                }
-                else if (vec.length > this.vectorDim) {
-                    vec.length = this.vectorDim;
+                // Never silently pad/truncate: a width mismatch means the embedding tier
+                // and this table disagree (wrong model wired, or a stale index after a
+                // tier change). Reshaping would store garbage that scores meaninglessly.
+                // Fail loudly and point at the fix instead.
+                if (vec.length !== this.vectorDim) {
+                    throw new Error(`Vector dimension mismatch: got ${vec.length}d, expected ${this.vectorDim}d. ` +
+                        "The embedding model tier likely changed without a rebuild — the shared " +
+                        `table is fixed-width, so run \`${config_1.REBUILD_COMMAND}\` (a per-project ` +
+                        "`gmax index --reset` cannot change the table width).");
                 }
                 rec.vector = vec;
                 rec.colbert = toBuffer(rec.colbert);
@@ -676,7 +710,7 @@ class VectorDB {
             const rows = yield table
                 .query()
                 .select(["id"])
-                .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                .where((0, filter_builder_1.pathStartsWith)(prefix))
                 .limit(1)
                 .toArray();
             return rows.length > 0;
@@ -686,7 +720,7 @@ class VectorDB {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.ensureTable();
             const prefix = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
-            return table.countRows(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`);
+            return table.countRows((0, filter_builder_1.pathStartsWith)(prefix));
         });
     }
     countDistinctFilesForPath(pathPrefix) {
@@ -701,7 +735,7 @@ class VectorDB {
             const rows = yield table
                 .query()
                 .select(["path"])
-                .where(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                .where((0, filter_builder_1.pathStartsWith)(prefix))
                 .toArray();
             const unique = new Set();
             for (const r of rows) {
@@ -804,7 +838,12 @@ class VectorDB {
         return __awaiter(this, void 0, void 0, function* () {
             this.ensureDiskOk();
             const table = yield this.ensureTable();
-            yield this.withWriteGate(() => table.delete(`path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`));
+            // Slash-terminate so a project root can't bleed into a sibling
+            // (`/repo/app` must not delete `/repo/app2`), and use starts_with so `_`/`%`
+            // in the path are literal, not LIKE wildcards. Destructive path — keep this
+            // self-protective even if a caller forgets to normalize.
+            const dirPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+            yield this.withWriteGate(() => table.delete((0, filter_builder_1.pathStartsWith)(dirPrefix)));
         });
     }
     drop() {

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

@@ -45,6 +45,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.isDaemonRunning = isDaemonRunning;
 exports.isDaemonHeartbeatFresh = isDaemonHeartbeatFresh;
+exports.readDaemonPid = readDaemonPid;
+exports.waitForProcessExit = waitForProcessExit;
+exports.writeDrainingMarker = writeDrainingMarker;
+exports.clearDrainingMarker = clearDrainingMarker;
+exports.isDaemonDraining = isDaemonDraining;
 exports.ensureDaemonRunning = ensureDaemonRunning;
 exports.sendStreamingCommand = sendStreamingCommand;
 const fs = __importStar(require("node:fs"));
@@ -152,6 +157,88 @@ function isDaemonHeartbeatFresh() {
         return false;
     }
 }
+/** Read the daemon's PID from the PID file, or null if absent/invalid. */
+function readDaemonPid() {
+    try {
+        const pid = parseInt(fs.readFileSync(config_1.PATHS.daemonPidFile, "utf-8").trim(), 10);
+        return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Poll until a process has fully exited, or the timeout elapses. Used before
+ * spawning a successor daemon: shutdown() drops the socket/lock immediately but
+ * keeps draining in-flight work, and a successor that starts in that window
+ * classifies the still-draining predecessor as stale and SIGKILLs it. Waiting
+ * for the actual process exit closes that race. Returns true if it exited.
+ */
+function waitForProcessExit(pid, timeoutMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (_a) {
+                return true; // ESRCH — process is gone
+            }
+            yield new Promise((r) => setTimeout(r, 100));
+        }
+        return false;
+    });
+}
+// A daemon's graceful shutdown can run well past the 20s restart wait — worker
+// SIGTERM→SIGKILL escalation (5s), maintenance drain (10s), LanceDB close (5s),
+// 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;
+/**
+ * Record that this daemon (pid) has begun graceful shutdown, so a successor's
+ * killStaleProcesses() won't SIGKILL it mid-cleanup after it drops its
+ * socket/PID/lock liveness markers. Best-effort; cleared by clearDrainingMarker
+ * on a clean exit and otherwise self-expires after DRAIN_GRACE_MS.
+ */
+function writeDrainingMarker(pid) {
+    try {
+        fs.mkdirSync(config_1.PATHS.globalRoot, { recursive: true });
+        fs.writeFileSync(config_1.PATHS.daemonDrainingFile, JSON.stringify({ pid, ts: Date.now() }));
+    }
+    catch (_a) { }
+}
+/** Remove the draining marker (clean end of shutdown). */
+function clearDrainingMarker() {
+    try {
+        fs.unlinkSync(config_1.PATHS.daemonDrainingFile);
+    }
+    catch (_a) { }
+}
+/**
+ * True if `pid` is a daemon currently inside graceful shutdown: a fresh draining
+ * marker naming that exact PID, and the process is still alive. A stale marker
+ * (older than DRAIN_GRACE_MS), a mismatched PID, or a dead process all read as
+ * "not draining" so a wedged or already-exited predecessor is still reclaimable.
+ */
+function isDaemonDraining(pid) {
+    try {
+        const { pid: markerPid, ts } = JSON.parse(fs.readFileSync(config_1.PATHS.daemonDrainingFile, "utf-8"));
+        if (markerPid !== pid)
+            return false;
+        if (typeof ts !== "number" || Date.now() - ts > DRAIN_GRACE_MS)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (_a) {
+            return false; // process already gone — done draining
+        }
+    }
+    catch (_b) {
+        return false; // no marker / unreadable
+    }
+}
 /**
  * Ensure the daemon is running — start it if needed, poll up to 5s.
  * Returns true if daemon is ready, false if it couldn't be started.

package/dist/lib/utils/filter-builder.js

@@ -1,12 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeSqlString = escapeSqlString;
+exports.pathStartsWith = pathStartsWith;
+exports.pathNotStartsWith = pathNotStartsWith;
 exports.normalizePath = normalizePath;
 function escapeSqlString(str) {
     // LanceDB (via DataFusion) treats backslashes literally in standard strings.
     // We only need to escape single quotes by doubling them.
     return str.replace(/'/g, "''");
 }
+/**
+ * SQL predicate matching rows whose `path` begins with `prefix`.
+ *
+ * Use this instead of `path LIKE '<prefix>%'` for any path-prefix scope.
+ * `escapeSqlString` only neutralizes quotes, not LIKE metacharacters, so a
+ * prefix containing `_` (matches any single char) or `%` (matches anything)
+ * would silently match — and delete — across sibling projects
+ * (`/repo/my_app/` would match `/repo/myXapp/`). `starts_with()` has no
+ * wildcard semantics, so the prefix is matched literally.
+ *
+ * Callers are responsible for trailing-slash boundary correctness: pass
+ * `/repo/app/` (not `/repo/app`) so the scope can't bleed into `/repo/app2/`.
+ */
+function pathStartsWith(prefix) {
+    return `starts_with(path, '${escapeSqlString(prefix)}')`;
+}
+/** Negation of {@link pathStartsWith} — excludes paths under `prefix`. */
+function pathNotStartsWith(prefix) {
+    return `NOT ${pathStartsWith(prefix)}`;
+}
 /**
  * Normalizes a path to use forward slashes, ensuring consistency across platforms.
  * @param p The path to normalize

package/dist/lib/utils/scope-filter.js

@@ -92,14 +92,12 @@ function buildScopeWhere(scope, condition) {
     const parts = [];
     if (condition)
         parts.push(condition);
-    parts.push(`path LIKE '${(0, filter_builder_1.escapeSqlString)(scope.pathPrefix)}%'`);
+    parts.push((0, filter_builder_1.pathStartsWith)(scope.pathPrefix));
     for (const ex of scope.excludePrefixes) {
-        parts.push(`path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(ex)}%'`);
+        parts.push((0, filter_builder_1.pathNotStartsWith)(ex));
     }
     if (scope.inPrefixes.length > 0) {
-        const ors = scope.inPrefixes
-            .map((p) => `path LIKE '${(0, filter_builder_1.escapeSqlString)(p)}%'`)
-            .join(" OR ");
+        const ors = scope.inPrefixes.map((p) => (0, filter_builder_1.pathStartsWith)(p)).join(" OR ");
         parts.push(`(${ors})`);
     }
     return parts.join(" AND ");

package/dist/lib/workers/embeddings/granite.js

@@ -63,7 +63,10 @@ class GraniteModel {
         this.vectorDimensions = vectorDim !== null && vectorDim !== void 0 ? vectorDim : config_1.CONFIG.VECTOR_DIM;
     }
     resolvePaths() {
-        const basePath = path.join(CACHE_DIR, config_1.MODEL_IDS.embed);
+        // Honor the active tier's ONNX model (propagated from the pool); fall back
+        // to the small-tier default when unset (standalone/test invocations).
+        const modelId = process.env.GMAX_EMBED_ONNX_MODEL || config_1.MODEL_IDS.embed;
+        const basePath = path.join(CACHE_DIR, modelId);
         const onnxDir = path.join(basePath, "onnx");
         const candidates = ["model_q4.onnx", "model.onnx"];
         for (const candidate of candidates) {

package/dist/lib/workers/pool.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerPool = void 0;
+exports.embeddingEnv = embeddingEnv;
 exports.getWorkerPool = getWorkerPool;
 exports.destroyWorkerPool = destroyWorkerPool;
 exports.isWorkerPoolInitialized = isWorkerPoolInitialized;
@@ -54,6 +55,7 @@ const childProcess = __importStar(require("node:child_process"));
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const index_config_1 = require("../index/index-config");
 const logger_1 = require("../utils/logger");
 function reviveBufferLike(input) {
     if (input &&
@@ -110,6 +112,22 @@ const FORCE_KILL_GRACE_MS = 200;
 // 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;
+/**
+ * Embedding env derived from the active model tier, injected into every spawned
+ * worker so the worker's VectorDB dim (GMAX_VECTOR_DIM) and CPU ONNX model
+ * (GMAX_EMBED_ONNX_MODEL) match the configured tier. Without this, workers fall
+ * back to the hard-wired small tier (384d) regardless of config. One spot covers
+ * every worker user (index, add, search, daemon, mcp). Merged so process.env can
+ * override — see the spread order at fork().
+ */
+function embeddingEnv() {
+    const { modelTier } = (0, index_config_1.readGlobalConfig)();
+    const ids = (0, index_config_1.getModelIdsForTier)(modelTier);
+    return {
+        GMAX_VECTOR_DIM: String(ids.vectorDim),
+        GMAX_EMBED_ONNX_MODEL: ids.embed,
+    };
+}
 class ProcessWorker {
     constructor(modulePath, execArgv, maxMemoryMb) {
         this.modulePath = modulePath;
@@ -127,9 +145,11 @@ class ProcessWorker {
         // fire for the same crash.
         this.cleanedUp = false;
         const memArgs = maxMemoryMb ? [`--max-old-space-size=${maxMemoryMb}`] : [];
+        // embeddingEnv() first so a manually-exported GMAX_VECTOR_DIM /
+        // GMAX_EMBED_ONNX_MODEL in process.env still wins (spread last).
         this.child = childProcess.fork(modulePath, {
             execArgv: [...memArgs, ...execArgv],
-            env: Object.assign({}, process.env),
+            env: Object.assign(Object.assign({}, embeddingEnv()), process.env),
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -65,6 +65,7 @@
   ],
   "files": [
     "dist",
+    ".claude-plugin",
     "plugins",
     "scripts/postinstall.js",
     "mlx-embed-server",

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

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

package/plugins/grepmax/agents/semantic-explore.md

@@ -41,7 +41,7 @@ gmax trace handleAuth -d 2
 
 **File structure** — collapsed signatures (~4x fewer tokens than reading):
 ```
-gmax skeleton src/lib/auth/
+gmax skeleton src/lib/auth.ts
 ```
 
 **Project overview** — languages, structure, key entry points:

package/plugins/grepmax/skills/grepmax/SKILL.md

@@ -116,7 +116,7 @@ Agent output ends with `t: <test-file>:line\t<test-symbol>\t<hop-label>` rows wh
 ### Skeleton — `gmax skeleton <target>`
 ```
 gmax skeleton src/lib/auth.ts              # single file
-gmax skeleton src/lib/search/              # entire directory
+gmax skeleton handleAuth                   # by symbol name (finds its file)
 gmax skeleton src/a.ts,src/b.ts            # batch
 gmax skeleton src/lib/auth.ts --json       # structured JSON output
 ```