grepmax 0.23.0 → 0.25.0

package/dist/lib/utils/project-registry.js

@@ -42,7 +42,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRegistryConflictError = void 0;
 exports.registerProject = registerProject;
+exports.reserveProjectsForRebuild = reserveProjectsForRebuild;
+exports.restoreProjectsAfterRebuild = restoreProjectsAfterRebuild;
+exports.markProjectRebuildDropping = markProjectRebuildDropping;
+exports.completeProjectRebuild = completeProjectRebuild;
+exports.hasUnfinishedProjectRebuild = hasUnfinishedProjectRebuild;
+exports.stampProjectFullSync = stampProjectFullSync;
 exports.listProjects = listProjects;
 exports.getProject = getProject;
 exports.removeProject = removeProject;
@@ -50,20 +57,125 @@ exports.getParentProject = getParentProject;
 exports.getChildProjects = getChildProjects;
 exports.resolveRootOrExit = resolveRootOrExit;
 exports.resolveProjectRoot = resolveProjectRoot;
+const node_crypto_1 = require("node:crypto");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
 const config_1 = require("../../config");
+const embedding_generation_1 = require("../index/embedding-generation");
 const REGISTRY_PATH = path.join(config_1.PATHS.globalRoot, "projects.json");
+const REBUILD_JOURNAL_PATH = path.join(config_1.PATHS.globalRoot, "rebuild-journal.json");
+class ProjectRegistryConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = "PROJECT_REGISTRY_CONFLICT";
+        this.name = "ProjectRegistryConflictError";
+    }
+}
+exports.ProjectRegistryConflictError = ProjectRegistryConflictError;
 function loadRegistry() {
+    let raw;
+    try {
+        raw = fs.readFileSync(REGISTRY_PATH, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to read project registry ${REGISTRY_PATH}: ${message}`);
+    }
+    let parsed;
     try {
-        const raw = fs.readFileSync(REGISTRY_PATH, "utf-8");
-        return JSON.parse(raw);
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid project registry JSON ${REGISTRY_PATH}: ${message}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`Invalid project registry ${REGISTRY_PATH}: expected an array`);
+    }
+    for (const [index, entry] of parsed.entries()) {
+        if (!isProjectEntry(entry)) {
+            throw new Error(`Invalid project registry entry at index ${index} in ${REGISTRY_PATH}`);
+        }
+    }
+    return parsed;
+}
+function isProjectEntry(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+    const value = entry;
+    const valid = typeof value.root === "string" &&
+        value.root.length > 0 &&
+        typeof value.name === "string" &&
+        value.name.length > 0 &&
+        typeof value.vectorDim === "number" &&
+        Number.isFinite(value.vectorDim) &&
+        value.vectorDim > 0 &&
+        typeof value.modelTier === "string" &&
+        typeof value.embedMode === "string" &&
+        typeof value.lastIndexed === "string" &&
+        (value.status === undefined ||
+            value.status === "pending" ||
+            value.status === "indexed" ||
+            value.status === "error") &&
+        (value.chunkCount === undefined ||
+            (typeof value.chunkCount === "number" &&
+                Number.isFinite(value.chunkCount) &&
+                value.chunkCount >= 0)) &&
+        (value.chunkerVersion === undefined ||
+            (typeof value.chunkerVersion === "number" &&
+                Number.isInteger(value.chunkerVersion) &&
+                value.chunkerVersion >= 0)) &&
+        optionalNonEmptyString(value.embedModel) &&
+        optionalNonEmptyString(value.mlxModel) &&
+        optionalNonEmptyString(value.colbertModel) &&
+        (value.embeddingFingerprint === undefined ||
+            (typeof value.embeddingFingerprint === "string" &&
+                /^[a-f0-9]{64}$/.test(value.embeddingFingerprint))) &&
+        optionalNonEmptyString(value.rebuildId);
+    if (!valid)
+        return false;
+    try {
+        if (value.embeddingFingerprint !== undefined) {
+            if (value.embedModel === undefined ||
+                value.mlxModel === undefined ||
+                value.colbertModel === undefined) {
+                return false;
+            }
+            return (value.embeddingFingerprint ===
+                (0, embedding_generation_1.computeEmbeddingFingerprint)({
+                    tier: value.modelTier,
+                    vectorDim: value.vectorDim,
+                    onnxModel: value.embedModel,
+                    mlxModel: value.mlxModel,
+                    colbertModel: value.colbertModel,
+                }));
+        }
+        // Unstamped records predate exact generation identities. Keep accepting
+        // their historical shape while retaining the old tier sanity checks.
+        const generation = (0, embedding_generation_1.resolveEmbeddingGeneration)(Object.assign({ modelTier: value.modelTier, vectorDim: value.vectorDim }, (value.mlxModel === undefined
+            ? {}
+            : { mlxModel: value.mlxModel })));
+        if ((value.embedModel !== undefined &&
+            value.embedModel !== generation.onnxModel) ||
+            (value.mlxModel !== undefined &&
+                value.mlxModel !== generation.mlxModel) ||
+            (value.colbertModel !== undefined &&
+                value.colbertModel !== generation.colbertModel)) {
+            return false;
+        }
+        return true;
     }
     catch (_a) {
-        return [];
+        return false;
     }
 }
+function optionalNonEmptyString(value) {
+    return (value === undefined ||
+        (typeof value === "string" && value.length > 0 && value === value.trim()));
+}
 function saveRegistry(entries) {
     fs.mkdirSync(path.dirname(REGISTRY_PATH), { recursive: true });
     const tmp = `${REGISTRY_PATH}.tmp`;
@@ -90,8 +202,31 @@ function withRegistryLock(fn) {
     }
 }
 function registerProject(entry) {
+    if (!isProjectEntry(entry)) {
+        throw new Error("Invalid project registry entry");
+    }
     withRegistryLock(() => {
         const entries = loadRegistry();
+        let canonicalRoot;
+        try {
+            canonicalRoot = fs.realpathSync(entry.root);
+        }
+        catch (_a) { }
+        if (canonicalRoot) {
+            const duplicate = entries.find((existing) => {
+                if (existing.root === entry.root)
+                    return false;
+                try {
+                    return fs.realpathSync(existing.root) === canonicalRoot;
+                }
+                catch (_a) {
+                    return false;
+                }
+            });
+            if (duplicate) {
+                throw new Error(`Project root resolves to already registered project ${duplicate.root}`);
+            }
+        }
         const idx = entries.findIndex((e) => e.root === entry.root);
         if (idx >= 0) {
             entries[idx] = entry;
@@ -102,6 +237,219 @@ function registerProject(entry) {
         saveRegistry(entries);
     });
 }
+function immutableEntries(entries) {
+    return Object.freeze(entries.map((entry) => Object.freeze(Object.assign({}, entry))));
+}
+function saveRebuildJournal(journal) {
+    fs.mkdirSync(path.dirname(REBUILD_JOURNAL_PATH), { recursive: true });
+    const temp = `${REBUILD_JOURNAL_PATH}.${journal.rebuildId}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(journal, null, 2)}\n`, {
+        flag: "wx",
+    });
+    fs.renameSync(temp, REBUILD_JOURNAL_PATH);
+}
+function parseRebuildJournal(filePath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw error;
+        throw new Error(`Invalid rebuild journal ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`Invalid rebuild journal ${filePath}`);
+    }
+    const journal = parsed;
+    if (typeof journal.rebuildId !== "string" ||
+        (journal.phase !== "reserved" && journal.phase !== "dropping") ||
+        typeof journal.targetFingerprint !== "string" ||
+        !Array.isArray(journal.previous) ||
+        !Array.isArray(journal.reserved) ||
+        !journal.previous.every(isProjectEntry) ||
+        !journal.reserved.every(isProjectEntry)) {
+        throw new Error(`Invalid rebuild journal ${filePath}`);
+    }
+    return journal;
+}
+function loadRebuildJournal() {
+    const dir = path.dirname(REBUILD_JOURNAL_PATH);
+    const prefix = `${path.basename(REBUILD_JOURNAL_PATH)}.`;
+    let temps = [];
+    try {
+        temps = fs
+            .readdirSync(dir)
+            .filter((name) => name.startsWith(prefix) && name.endsWith(".tmp"))
+            .map((name) => path.join(dir, name));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const validTemps = [];
+    for (const temp of temps) {
+        try {
+            validTemps.push({ path: temp, journal: parseRebuildJournal(temp) });
+        }
+        catch (_a) {
+            fs.rmSync(temp, { force: true });
+        }
+    }
+    if (validTemps.length > 1) {
+        throw new Error(`Multiple rebuild journal temp files found in ${dir}`);
+    }
+    if (validTemps.length === 1) {
+        const candidate = validTemps[0];
+        try {
+            const current = parseRebuildJournal(REBUILD_JOURNAL_PATH);
+            if (current.rebuildId !== candidate.journal.rebuildId) {
+                throw new Error("Rebuild journal temp identity changed");
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        fs.renameSync(candidate.path, REBUILD_JOURNAL_PATH);
+    }
+    try {
+        return parseRebuildJournal(REBUILD_JOURNAL_PATH);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function removeRebuildJournal(rebuildId) {
+    const current = loadRebuildJournal();
+    if ((current === null || current === void 0 ? void 0 : current.rebuildId) !== rebuildId)
+        return;
+    fs.rmSync(REBUILD_JOURNAL_PATH, { force: true });
+}
+function reserveProjectsForRebuild(generation) {
+    return withRegistryLock(() => {
+        const entries = loadRegistry();
+        const existingJournal = loadRebuildJournal();
+        if (existingJournal) {
+            if (existingJournal.targetFingerprint !== generation.fingerprint) {
+                throw new ProjectRegistryConflictError("Configured embedding changed during an unfinished rebuild");
+            }
+            const previousByRoot = new Map(existingJournal.previous.map((entry) => [entry.root, entry]));
+            const previous = immutableEntries(entries.map((entry) => { var _a; return (_a = previousByRoot.get(entry.root)) !== null && _a !== void 0 ? _a : entry; }));
+            const roots = new Set(entries.map((entry) => entry.root));
+            const resumed = entries.map((entry) => roots.has(entry.root)
+                ? Object.assign(Object.assign({}, entry), { vectorDim: generation.vectorDim, modelTier: generation.tier, embedModel: generation.onnxModel, mlxModel: generation.mlxModel, colbertModel: generation.colbertModel, embeddingFingerprint: generation.fingerprint, status: "pending", rebuildId: existingJournal.rebuildId }) : entry);
+            saveRebuildJournal(Object.assign(Object.assign({}, existingJournal), { previous, reserved: immutableEntries(resumed) }));
+            saveRegistry(resumed);
+            return Object.freeze({
+                rebuildId: existingJournal.rebuildId,
+                previous,
+                reserved: immutableEntries(resumed),
+            });
+        }
+        if (entries.some((entry) => entry.rebuildId)) {
+            throw new ProjectRegistryConflictError("A project is already reserved by an active rebuild");
+        }
+        const rebuildId = (0, node_crypto_1.randomUUID)();
+        const previous = immutableEntries(entries);
+        const reservedEntries = entries.map((entry) => (Object.assign(Object.assign({}, entry), { vectorDim: generation.vectorDim, modelTier: generation.tier, embedModel: generation.onnxModel, mlxModel: generation.mlxModel, colbertModel: generation.colbertModel, embeddingFingerprint: generation.fingerprint, status: "pending", rebuildId })));
+        if (!reservedEntries.every(isProjectEntry)) {
+            throw new Error("Invalid rebuild generation reservation");
+        }
+        const journal = {
+            rebuildId,
+            phase: "reserved",
+            targetFingerprint: generation.fingerprint,
+            previous,
+            reserved: immutableEntries(reservedEntries),
+        };
+        saveRebuildJournal(journal);
+        try {
+            saveRegistry(reservedEntries);
+        }
+        catch (error) {
+            removeRebuildJournal(rebuildId);
+            throw error;
+        }
+        return Object.freeze({
+            rebuildId,
+            previous,
+            reserved: immutableEntries(reservedEntries),
+        });
+    });
+}
+function restoreProjectsAfterRebuild(reservation) {
+    withRegistryLock(() => {
+        const entries = loadRegistry();
+        const previousByRoot = new Map(reservation.previous.map((entry) => [entry.root, entry]));
+        let changed = false;
+        const restored = entries.map((entry) => {
+            if (entry.rebuildId !== reservation.rebuildId)
+                return entry;
+            const previous = previousByRoot.get(entry.root);
+            if (!previous)
+                return entry;
+            changed = true;
+            return Object.assign({}, previous);
+        });
+        if (changed)
+            saveRegistry(restored);
+        removeRebuildJournal(reservation.rebuildId);
+    });
+}
+function markProjectRebuildDropping(reservation) {
+    withRegistryLock(() => {
+        const journal = loadRebuildJournal();
+        if (!journal || journal.rebuildId !== reservation.rebuildId) {
+            throw new ProjectRegistryConflictError("Project rebuild journal identity changed");
+        }
+        saveRebuildJournal(Object.assign(Object.assign({}, journal), { phase: "dropping" }));
+    });
+}
+function completeProjectRebuild(rebuildId) {
+    withRegistryLock(() => {
+        const remaining = loadRegistry().some((entry) => entry.rebuildId === rebuildId);
+        if (remaining) {
+            throw new ProjectRegistryConflictError("Cannot complete rebuild while projects remain pending");
+        }
+        removeRebuildJournal(rebuildId);
+    });
+}
+function hasUnfinishedProjectRebuild() {
+    return withRegistryLock(() => loadRebuildJournal() !== null);
+}
+function stampProjectFullSync(stamp) {
+    return withRegistryLock(() => {
+        var _a, _b, _c, _d, _e;
+        const entries = loadRegistry();
+        const idx = entries.findIndex((entry) => entry.root === stamp.root);
+        const previous = idx >= 0 ? entries[idx] : undefined;
+        if ((previous === null || previous === void 0 ? void 0 : previous.rebuildId) && stamp.expectedRebuildId === undefined) {
+            throw new ProjectRegistryConflictError("Project is reserved by an active rebuild");
+        }
+        if (stamp.expectedFingerprint !== undefined &&
+            ((_a = previous === null || previous === void 0 ? void 0 : previous.embeddingFingerprint) !== null && _a !== void 0 ? _a : null) !== stamp.expectedFingerprint) {
+            throw new ProjectRegistryConflictError("Project embedding fingerprint changed during indexing");
+        }
+        if (stamp.expectedRebuildId !== undefined &&
+            ((_b = previous === null || previous === void 0 ? void 0 : previous.rebuildId) !== null && _b !== void 0 ? _b : null) !== stamp.expectedRebuildId) {
+            throw new ProjectRegistryConflictError("Project rebuild identity changed during indexing");
+        }
+        const entry = Object.assign(Object.assign({}, previous), { root: stamp.root, name: (_d = (_c = stamp.name) !== null && _c !== void 0 ? _c : previous === null || previous === void 0 ? void 0 : previous.name) !== null && _d !== void 0 ? _d : path.basename(stamp.root), vectorDim: stamp.generation.vectorDim, modelTier: stamp.generation.tier, embedMode: stamp.embedMode, embedModel: stamp.generation.onnxModel, mlxModel: stamp.generation.mlxModel, colbertModel: stamp.generation.colbertModel, embeddingFingerprint: stamp.generation.fingerprint, lastIndexed: (_e = stamp.indexedAt) !== null && _e !== void 0 ? _e : new Date().toISOString(), chunkCount: stamp.chunkCount, status: "indexed", chunkerVersion: stamp.chunkerVersion });
+        delete entry.rebuildId;
+        if (!isProjectEntry(entry)) {
+            throw new Error("Invalid full-sync project stamp");
+        }
+        if (idx >= 0)
+            entries[idx] = entry;
+        else
+            entries.push(entry);
+        saveRegistry(entries);
+        return entry;
+    });
+}
 function listProjects() {
     return loadRegistry();
 }

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

@@ -37,6 +37,7 @@ exports.resolveScope = resolveScope;
 exports.buildScopeWhere = buildScopeWhere;
 const path = __importStar(require("node:path"));
 const filter_builder_1 = require("./filter-builder");
+const path_containment_1 = require("./path-containment");
 function toArray(value) {
     if (value === undefined)
         return [];
@@ -49,15 +50,8 @@ function toArray(value) {
         .filter(Boolean);
 }
 function joinSubpath(projectRoot, sub) {
-    const rootWithSlash = projectRoot.endsWith("/")
-        ? projectRoot
-        : `${projectRoot}/`;
-    if (path.isAbsolute(sub))
-        return sub.endsWith("/") ? sub : `${sub}/`;
-    if (sub.startsWith(rootWithSlash))
-        return sub.endsWith("/") ? sub : `${sub}/`;
-    const joined = path.join(rootWithSlash, sub);
-    return joined.endsWith("/") ? joined : `${joined}/`;
+    const resolved = (0, path_containment_1.resolveContainedPath)(projectRoot, sub);
+    return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
 }
 function resolveScope(opts) {
     const { projectRoot } = opts;

package/dist/lib/utils/stale-hint.js

@@ -19,6 +19,7 @@ exports.maybeWarnCrossProjectDim = maybeWarnCrossProjectDim;
  * chunker does not mask a stale embedding). Suppress all with GMAX_NO_STALE_HINT=1.
  */
 const config_1 = require("../../config");
+const embedding_status_1 = require("../index/embedding-status");
 const index_config_1 = require("../index/index-config");
 const project_registry_1 = require("./project-registry");
 let chunkerEmitted = false;
@@ -89,8 +90,8 @@ function maybeWarnStaleEmbedding(projectRoot, opts) {
     if (project.status && project.status !== "indexed")
         return;
     const current = (0, index_config_1.readGlobalConfig)();
-    const gap = (0, config_1.describeEmbeddingGap)({ modelTier: project.modelTier, vectorDim: project.vectorDim }, { modelTier: current.modelTier, vectorDim: current.vectorDim });
-    if (!gap)
+    const identity = (0, embedding_status_1.projectEmbeddingStatus)(project, current);
+    if (identity.state !== "stale" || !identity.built)
         return;
     embeddingEmitted = true;
     const name = project.name || projectRoot;
@@ -98,27 +99,19 @@ function maybeWarnStaleEmbedding(projectRoot, opts) {
         const fields = [
             "stale_embedding",
             `project=${name}`,
-            `indexed_model=${gap.fromModel}`,
-            `current_model=${gap.toModel}`,
-            `indexed_dim=${gap.fromDim}`,
-            `current_dim=${gap.toDim}`,
-            `dim_changed=${gap.dimChanged}`,
-            `severity=${gap.severity}`,
-            // A dim change needs the global rebuild (shared table is fixed-width); a
-            // same-dim model swap can use a per-project reset.
-            `fix=${gap.dimChanged ? config_1.REBUILD_COMMAND : "gmax index --reset"}`,
+            `indexed_model=${identity.built.tier}`,
+            `current_model=${identity.configured.tier}`,
+            `indexed_dim=${identity.built.vectorDim}`,
+            `current_dim=${identity.configured.vectorDim}`,
+            `indexed_fingerprint=${identity.built.fingerprint}`,
+            `current_fingerprint=${identity.configured.fingerprint}`,
+            "severity=breaking",
+            "fix=gmax repair --rebuild",
         ].join("\t");
         process.stderr.write(`${fields}\n`);
         return;
     }
-    const label = gap.severity === "breaking" ? "WARN" : "hint";
-    const detail = gap.dimChanged
-        ? `vector dim ${gap.fromDim}→${gap.toDim} (incompatible — scores invalid until re-embed)`
-        : `model '${gap.fromModel}'→'${gap.toModel}' (same dim; results mix models until re-embed)`;
-    const fix = gap.dimChanged
-        ? `Run '${config_1.REBUILD_COMMAND}'`
-        : "Run 'gmax index --reset'";
-    process.stderr.write(`${label}  gmax: '${name}' indexed with embedding ${detail}. ${fix}. (silence: GMAX_NO_STALE_HINT=1)\n`);
+    process.stderr.write(`WARN  gmax: '${name}' uses a stale embedding generation (${identity.built.tier} ${identity.built.vectorDim}d → ${identity.configured.tier} ${identity.configured.vectorDim}d). Run 'gmax repair --rebuild' to rebuild the whole corpus. (silence: GMAX_NO_STALE_HINT=1)\n`);
 }
 /**
  * Cross-project guard: when a `--all-projects` / `--projects` search spans

package/dist/lib/utils/watcher-launcher.js

@@ -51,7 +51,7 @@ function launchWatcher(projectRoot) {
         // 4. Daemon not running — try to start it, poll until ready
         const error = resp.error;
         if (error === "ENOENT" || error === "ECONNREFUSED") {
-            const daemonPid = (0, daemon_launcher_1.spawnDaemon)();
+            const daemonPid = yield (0, daemon_launcher_1.spawnDaemon)();
             if (daemonPid) {
                 for (let i = 0; i < 25; i++) {
                     yield new Promise((r) => setTimeout(r, 200));
@@ -71,6 +71,10 @@ function launchWatcher(projectRoot) {
         // 5. Fall back to per-project spawn
         try {
             const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--path", projectRoot, "-b"], { detached: true, stdio: "ignore" });
+            yield new Promise((resolve, reject) => {
+                child.once("spawn", resolve);
+                child.once("error", reject);
+            });
             child.unref();
             if (child.pid) {
                 return { ok: true, pid: child.pid, reused: false };

package/dist/lib/utils/watcher-store.js

@@ -99,12 +99,12 @@ function registerWatcher(info) {
     }
     db.put(info.projectRoot, Object.assign(Object.assign({}, info), { lastHeartbeat: Date.now() }));
 }
-function updateWatcherStatus(pid, status, lastReindex) {
+function updateWatcherStatus(pid, status, lastReindex, lastError) {
     const db = getDb();
     // Find entry by PID (iterate since key is projectRoot)
     for (const { key, value } of db.getRange()) {
         if (value && value.pid === pid) {
-            db.put(String(key), Object.assign(Object.assign(Object.assign({}, value), { status, lastHeartbeat: Date.now() }), (lastReindex ? { lastReindex } : {})));
+            db.put(String(key), Object.assign(Object.assign(Object.assign(Object.assign({}, value), { status, lastHeartbeat: Date.now() }), (lastReindex ? { lastReindex } : {})), (lastError ? { lastError } : { lastError: undefined })));
             return;
         }
     }

package/dist/lib/workers/colbert-math.js

@@ -39,19 +39,20 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const simsimd_1 = require("simsimd");
 const config_1 = require("../../config");
-let SKIP_IDS = null;
-function loadSkipIds() {
-    if (SKIP_IDS)
-        return SKIP_IDS;
+const SKIP_IDS = new Map();
+function loadSkipIds(modelId) {
+    const cached = SKIP_IDS.get(modelId);
+    if (cached)
+        return cached;
     // Check local models first (same logic as orchestrator)
     const PROJECT_ROOT = process.env.GMAX_PROJECT_ROOT
         ? path.resolve(process.env.GMAX_PROJECT_ROOT)
         : process.cwd();
     const localModels = path.join(PROJECT_ROOT, "models");
-    const localColbert = path.join(localModels, ...config_1.MODEL_IDS.colbert.split("/"));
+    const localColbert = path.join(localModels, ...modelId.split("/"));
     const localSkipPath = path.join(localColbert, "skiplist.json");
     // Try local first, then global
-    const globalBasePath = path.join(config_1.PATHS.models, ...config_1.MODEL_IDS.colbert.split("/"));
+    const globalBasePath = path.join(config_1.PATHS.models, ...modelId.split("/"));
     const globalSkipPath = path.join(globalBasePath, "skiplist.json");
     const skipPath = fs.existsSync(localSkipPath)
         ? localSkipPath
@@ -59,24 +60,26 @@ function loadSkipIds() {
     if (fs.existsSync(skipPath)) {
         try {
             const parsed = JSON.parse(fs.readFileSync(skipPath, "utf8"));
-            SKIP_IDS = new Set(parsed.map((n) => Number(n)));
-            return SKIP_IDS;
+            const ids = new Set(parsed.map((n) => Number(n)));
+            SKIP_IDS.set(modelId, ids);
+            return ids;
         }
         catch (_e) {
             // fall through to empty set
         }
     }
-    SKIP_IDS = new Set();
-    return SKIP_IDS;
+    const ids = new Set();
+    SKIP_IDS.set(modelId, ids);
+    return ids;
 }
-function maxSim(queryEmbeddings, docEmbeddings, docTokenIds) {
+function maxSim(queryEmbeddings, docEmbeddings, docTokenIds, modelId = config_1.MODEL_IDS.colbert) {
     if (queryEmbeddings.length === 0 || docEmbeddings.length === 0) {
         return 0;
     }
     const qVecs = queryEmbeddings.map((v) => v instanceof Float32Array ? v : new Float32Array(v));
     const dVecs = docEmbeddings.map((v) => v instanceof Float32Array ? v : new Float32Array(v));
     const dTokenIds = docTokenIds && docTokenIds.length === dVecs.length ? docTokenIds : null;
-    const skipIds = loadSkipIds();
+    const skipIds = loadSkipIds(modelId);
     let totalScore = 0;
     for (const qVec of qVecs) {
         let maxDotProduct = -Infinity;

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

@@ -57,7 +57,8 @@ const log = (...args) => {
         console.log(...args);
 };
 class ColbertModel {
-    constructor() {
+    constructor(modelId = config_1.MODEL_IDS.colbert) {
+        this.modelId = modelId;
         this.session = null;
         this.tokenizer = null;
     }
@@ -66,7 +67,7 @@ class ColbertModel {
             if (this.session && this.tokenizer)
                 return;
             this.tokenizer = new colbert_tokenizer_1.ColBERTTokenizer();
-            const basePath = path.join(CACHE_DIR, config_1.MODEL_IDS.colbert);
+            const basePath = path.join(CACHE_DIR, this.modelId);
             const onnxDir = path.join(basePath, "onnx");
             const modelPath = path.join(onnxDir, "model_int8.onnx");
             if (!fs.existsSync(modelPath)) {

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

@@ -57,7 +57,9 @@ const log = (...args) => {
         console.log(...args);
 };
 class GraniteModel {
-    constructor(vectorDim) {
+    constructor(vectorDim, modelId = process.env.GMAX_EMBED_ONNX_MODEL ||
+        config_1.MODEL_IDS.embed) {
+        this.modelId = modelId;
         this.session = null;
         this.tokenizer = null;
         this.vectorDimensions = vectorDim !== null && vectorDim !== void 0 ? vectorDim : config_1.CONFIG.VECTOR_DIM;
@@ -65,8 +67,7 @@ class GraniteModel {
     resolvePaths() {
         // 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 basePath = path.join(CACHE_DIR, this.modelId);
         const onnxDir = path.join(basePath, "onnx");
         const candidates = ["model_q4.onnx", "model.onnx"];
         for (const candidate of candidates) {