grepmax 0.26.70 → 0.26.71

package/dist/lib/mcp/document-contract.js

@@ -0,0 +1,281 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCUMENT_STATES = exports.DOCUMENT_LIMITS = exports.DOCUMENT_CAPABILITIES = exports.DOCUMENT_CONTRACT_VERSION = void 0;
+exports.documentFailure = documentFailure;
+exports.inside = inside;
+exports.selectDocumentContext = selectDocumentContext;
+exports.documentPaths = documentPaths;
+exports.documentCoveragePaths = documentCoveragePaths;
+exports.documentGeneration = documentGeneration;
+exports.documentIndexedAt = documentIndexedAt;
+exports.documentMtime = documentMtime;
+exports.documentIndexState = documentIndexState;
+exports.documentQueryState = documentQueryState;
+exports.canonicalPointer = canonicalPointer;
+// This module is shared by the bridge and daemon. Node built-ins only.
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const stores_1 = require("../utils/stores");
+exports.DOCUMENT_CONTRACT_VERSION = 1;
+exports.DOCUMENT_CAPABILITIES = Object.freeze({
+    existingIndexOnly: 1,
+    queryLogging: false,
+    watch: false,
+    runtimeStartup: false,
+});
+exports.DOCUMENT_LIMITS = Object.freeze({
+    query: 500,
+    prefixes: 32,
+    paths: 2000,
+    pathBytes: 512 * 1024,
+    frameBytes: 1024 * 1024,
+    candidates: 50,
+    deadlineMs: 10000,
+});
+exports.DOCUMENT_STATES = new Set([
+    "unsupported_tool",
+    "unsupported_daemon",
+    "no_index",
+    "index_unavailable",
+    "daemon_unavailable",
+    "store_unavailable",
+    "embedding_unavailable",
+    "embedding_mismatch",
+    "host_pressure",
+    "busy",
+    "cancelled",
+    "timeout",
+    "no_coverage",
+    "search_unavailable",
+]);
+function documentFailure(state) {
+    return {
+        ok: false,
+        state: exports.DOCUMENT_STATES.has(state) ? state : "search_unavailable",
+    };
+}
+function inside(parent, child) {
+    const rel = path.relative(parent, child);
+    return (rel === "" ||
+        (!rel.startsWith(`..${path.sep}`) && rel !== ".." && !path.isAbsolute(rel)));
+}
+function selectDocumentContext(home, cwd) {
+    const checkout = fs.realpathSync(cwd);
+    try {
+        if (fs.statSync((0, stores_1.storesFilePath)()).size > exports.DOCUMENT_LIMITS.frameBytes)
+            throw new Error("store_unavailable");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if ((0, stores_1.matchStore)(checkout).kind !== "primary" ||
+        process.env.GMAX_SECONDARY_STORE === "1")
+        throw new Error("store_unavailable");
+    const registry = path.join(home, "projects.json");
+    let projects;
+    try {
+        if (fs.statSync(registry).size > exports.DOCUMENT_LIMITS.frameBytes)
+            throw new Error();
+        projects = JSON.parse(fs.readFileSync(registry, "utf8"));
+    }
+    catch (_a) {
+        throw new Error("no_index");
+    }
+    if (!Array.isArray(projects))
+        throw new Error("no_index");
+    const roots = [];
+    for (const project of projects) {
+        if (!project ||
+            typeof project.root !== "string" ||
+            !path.isAbsolute(project.root) ||
+            project.status === "error")
+            continue;
+        try {
+            const root = fs.realpathSync(project.root);
+            if (inside(root, checkout))
+                roots.push({
+                    root,
+                    wireRoot: project.root,
+                    lastIndexed: documentIndexedAt(project.lastIndexed),
+                });
+        }
+        catch (_b) {
+            /* deleted registry root */
+        }
+    }
+    roots.sort((a, b) => b.root.length - a.root.length);
+    if (!roots[0])
+        throw new Error("no_index");
+    return Object.assign(Object.assign({}, roots[0]), { checkout, store: path.join(home, "lancedb") });
+}
+function documentPaths(value, context, mode) {
+    return resolveDocumentPaths(value, context, mode, false).paths;
+}
+/** A disappearing sampled file reduces coverage; it cannot broaden retrieval. */
+function documentCoveragePaths(value, context) {
+    return resolveDocumentPaths(value, context, "paths", true);
+}
+function resolveDocumentPaths(value, context, mode, allowMissing) {
+    if (!Array.isArray(value) ||
+        value.length > exports.DOCUMENT_LIMITS[mode] ||
+        (mode === "prefixes" && !value.length) ||
+        Buffer.byteLength(JSON.stringify(value)) > exports.DOCUMENT_LIMITS.pathBytes)
+        throw new Error("no_coverage");
+    const paths = [
+        ...new Set(value.flatMap((input) => {
+            var _a;
+            if (typeof input !== "string" ||
+                !input ||
+                input.includes("\0") ||
+                !path.isAbsolute(input))
+                throw new Error("no_coverage");
+            let real;
+            try {
+                real = fs.realpathSync(input);
+            }
+            catch (error) {
+                const code = error.code;
+                if (allowMissing &&
+                    (code === "ENOENT" || code === "ENOTDIR") &&
+                    path.extname(input).toLowerCase() === ".md") {
+                    // Validate the nearest surviving parent too: missing paths outside
+                    // the selected scope are invalid, not silently accepted coverage.
+                    let parent = path.dirname(path.resolve(input));
+                    for (;;) {
+                        try {
+                            const realParent = fs.realpathSync(parent);
+                            if (!inside(context.checkout, realParent) ||
+                                !inside(context.root, realParent))
+                                throw new Error("no_coverage");
+                            return [];
+                        }
+                        catch (parentError) {
+                            if (!["ENOENT", "ENOTDIR"].includes((_a = parentError.code) !== null && _a !== void 0 ? _a : "") ||
+                                parent === path.dirname(parent))
+                                throw new Error("no_coverage");
+                            parent = path.dirname(parent);
+                        }
+                    }
+                }
+                throw new Error("no_coverage");
+            }
+            if (!inside(context.checkout, real) ||
+                !inside(context.root, real) ||
+                (mode === "paths" &&
+                    (path.extname(real).toLowerCase() !== ".md" ||
+                        !fs.statSync(real).isFile())))
+                throw new Error("no_coverage");
+            return [path.join(context.wireRoot, path.relative(context.root, real))];
+        })),
+    ];
+    if (Buffer.byteLength(JSON.stringify(paths)) > exports.DOCUMENT_LIMITS.pathBytes)
+        throw new Error("no_coverage");
+    return { paths, requested: new Set(value).size };
+}
+function documentGeneration(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function documentIndexedAt(value) {
+    return typeof value === "string" &&
+        value.length <= 40 &&
+        /^\d{4}-\d{2}-\d{2}(?:T[\d:.]+(?:Z|[+-]\d{2}:\d{2}))?$/.test(value) &&
+        Number.isFinite(Date.parse(value))
+        ? value
+        : null;
+}
+function documentMtime(value) {
+    return typeof value === "number" &&
+        Number.isFinite(value) &&
+        value >= 0 &&
+        value <= 8640000000000000
+        ? value
+        : null;
+}
+/** Deliberate metadata allowlist; no free-form diagnostics or cached content. */
+function documentIndexState(value) {
+    const source = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    const out = {};
+    const has = (key) => Object.getOwnPropertyDescriptor(source, key) !== undefined;
+    let invalid = typeof source.indexing !== "boolean";
+    for (const key of ["indexing", "verifying", "degraded", "catchupRunning"])
+        if (typeof source[key] === "boolean")
+            out[key] = source[key];
+        else if (has(key))
+            invalid = true;
+    for (const key of ["pendingFiles", "failedFiles", "overflowCount"])
+        if (typeof source[key] === "number" &&
+            Number.isSafeInteger(source[key]) &&
+            source[key] >= 0)
+            out[key] = source[key];
+        else if (has(key))
+            invalid = true;
+    for (const key of ["lastReconciledAt", "catchupMs"])
+        if (documentMtime(source[key]) !== null)
+            out[key] = source[key];
+        else if (has(key))
+            invalid = true;
+    if (typeof source.watcherMode === "string" &&
+        ["native", "polling", "recovering"].includes(source.watcherMode))
+        out.watcherMode = source.watcherMode;
+    else if (has("watcherMode"))
+        invalid = true;
+    if (invalid)
+        out.degraded = true;
+    return out;
+}
+function documentQueryState(value) {
+    return typeof value === "string" &&
+        ["ready", "busy", "embedding_unavailable", "host_pressure"].includes(value)
+        ? value
+        : "embedding_unavailable";
+}
+function canonicalPointer(input, context) {
+    try {
+        const real = fs.realpathSync(input);
+        return inside(context.checkout, real) &&
+            inside(context.root, real) &&
+            path.extname(real).toLowerCase() === ".md" &&
+            fs.statSync(real).isFile()
+            ? real
+            : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}

package/dist/lib/mcp/document-search.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDocumentCommand = sendDocumentCommand;
+exports.runDocumentSearchBridge = runDocumentSearchBridge;
+// Dedicated stdio surface: no normal CLI, workers, models, native stores or watchers.
+const net = __importStar(require("node:net"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_string_decoder_1 = require("node:string_decoder");
+const server_1 = require("@modelcontextprotocol/server");
+const stdio_1 = require("@modelcontextprotocol/server/stdio");
+const zod_1 = require("zod");
+const document_contract_1 = require("./document-contract");
+function sendDocumentCommand(socketPath, cmd, signal) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ path: socketPath });
+        const decoder = new node_string_decoder_1.StringDecoder("utf8");
+        let settled = false, bytes = 0, buffer = "";
+        const finish = (response) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            socket.destroy();
+            resolve(response);
+        };
+        const abort = () => { var _a; return finish((0, document_contract_1.documentFailure)(((_a = signal.reason) === null || _a === void 0 ? void 0 : _a.name) === "TimeoutError" ? "timeout" : "cancelled")); };
+        const timer = setTimeout(() => finish((0, document_contract_1.documentFailure)("timeout")), document_contract_1.DOCUMENT_LIMITS.deadlineMs);
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+        socket.on("connect", () => socket.write(`${JSON.stringify(cmd)}\n`));
+        socket.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > document_contract_1.DOCUMENT_LIMITS.frameBytes) {
+                finish((0, document_contract_1.documentFailure)("search_unavailable"));
+                return;
+            }
+            buffer += decoder.write(chunk);
+            const nl = buffer.indexOf("\n");
+            if (nl < 0)
+                return;
+            try {
+                const response = JSON.parse(buffer.slice(0, nl));
+                finish(response && typeof response === "object" && !Array.isArray(response)
+                    ? response
+                    : (0, document_contract_1.documentFailure)("search_unavailable"));
+            }
+            catch (_a) {
+                finish((0, document_contract_1.documentFailure)("search_unavailable"));
+            }
+        });
+        socket.on("error", () => finish((0, document_contract_1.documentFailure)("daemon_unavailable")));
+        socket.on("close", () => finish((0, document_contract_1.documentFailure)("daemon_unavailable")));
+    });
+}
+function runDocumentSearchBridge() {
+    var _a;
+    const home = path.resolve((_a = process.env.GMAX_HOME) !== null && _a !== void 0 ? _a : path.join(os.homedir(), ".gmax"));
+    const socket = path.join(home, "daemon.sock");
+    const transport = new stdio_1.StdioServerTransport(process.stdin, process.stdout, {
+        maxBufferSize: document_contract_1.DOCUMENT_LIMITS.frameBytes,
+    });
+    (0, stdio_1.serveStdio)(() => {
+        const server = new server_1.McpServer({
+            name: "gmax-document-search",
+            version: "1",
+        });
+        const call = (name, args, signal) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            var _c, _d;
+            signal = AbortSignal.any([
+                signal,
+                AbortSignal.timeout(document_contract_1.DOCUMENT_LIMITS.deadlineMs),
+            ]);
+            let response;
+            try {
+                const context = (0, document_contract_1.selectDocumentContext)(home, process.cwd());
+                const selection = name === "document_search_status"
+                    ? (0, document_contract_1.documentCoveragePaths)(args.paths, context)
+                    : {
+                        paths: (0, document_contract_1.documentPaths)(args.prefixes, context, "prefixes"),
+                        requested: 0,
+                    };
+                const values = selection.paths;
+                const ping = yield sendDocumentCommand(socket, { cmd: "ping" }, signal);
+                if (ping.ok !== true)
+                    response = (0, document_contract_1.documentFailure)(typeof ping.state === "string"
+                        ? ping.state
+                        : "daemon_unavailable");
+                else if (((_a = ping.capabilities) === null || _a === void 0 ? void 0 : _a.existingIndexOnlySearch) !== 1)
+                    response = (0, document_contract_1.documentFailure)("unsupported_daemon");
+                else if (ping.ready !== true)
+                    response = (0, document_contract_1.documentFailure)("index_unavailable");
+                else if (!(0, document_contract_1.documentGeneration)(ping.resourceGeneration))
+                    response = (0, document_contract_1.documentFailure)("embedding_mismatch");
+                else {
+                    const result = yield sendDocumentCommand(socket, Object.assign({ cmd: name === "document_search_status"
+                            ? "documents.status"
+                            : "documents.search", contractVersion: document_contract_1.DOCUMENT_CONTRACT_VERSION, checkout: context.checkout, projectRoot: context.wireRoot, store: context.store, generation: ping.resourceGeneration }, (name === "document_search_status"
+                        ? { paths: args.paths }
+                        : { query: args.query, prefixes: values })), signal);
+                    if (result.ok !== true)
+                        response = (0, document_contract_1.documentFailure)(typeof result.state === "string"
+                            ? result.state
+                            : "search_unavailable");
+                    else if (result.root !== context.root ||
+                        result.store !== context.store ||
+                        !(0, document_contract_1.documentGeneration)(result.generation) ||
+                        result.generation !== ping.resourceGeneration)
+                        response = (0, document_contract_1.documentFailure)("embedding_mismatch");
+                    else if (name === "document_search_status") {
+                        const seen = new Set();
+                        const covered = (Array.isArray(result.covered) ? result.covered : [])
+                            .slice(0, document_contract_1.DOCUMENT_LIMITS.paths)
+                            .flatMap((row) => {
+                            const p = typeof (row === null || row === void 0 ? void 0 : row.path) === "string" && values.includes(row.path)
+                                ? (0, document_contract_1.canonicalPointer)(row.path, context)
+                                : null;
+                            if (!p || seen.has(p))
+                                return [];
+                            seen.add(p);
+                            return [
+                                Object.assign(Object.assign({ path: p }, pointerHash(row)), ((0, document_contract_1.documentMtime)(row.indexedMtimeMs) !== null
+                                    ? { indexedMtimeMs: row.indexedMtimeMs }
+                                    : {})),
+                            ];
+                        });
+                        response = {
+                            state: "ready",
+                            generation: result.generation,
+                            project: {
+                                root: context.root,
+                                store: context.store,
+                                lastIndexed: (_c = (0, document_contract_1.documentIndexedAt)(result.lastIndexed)) !== null && _c !== void 0 ? _c : context.lastIndexed,
+                            },
+                            embeddingReady: result.embeddingReady === true &&
+                                (0, document_contract_1.documentQueryState)(result.queryState) === "ready",
+                            queryState: (0, document_contract_1.documentQueryState)(result.queryState),
+                            covered,
+                            coverage: {
+                                requested: selection.requested,
+                                indexed: covered.length,
+                                partial: covered.length !== selection.requested ||
+                                    (0, document_contract_1.documentIndexState)(result.indexState).degraded === true ||
+                                    ((_b = result.coverage) === null || _b === void 0 ? void 0 : _b.partial) === true,
+                            },
+                            indexState: (0, document_contract_1.documentIndexState)(result.indexState),
+                        };
+                    }
+                    else {
+                        const matches = (Array.isArray(result.matches) ? result.matches : [])
+                            .slice(0, document_contract_1.DOCUMENT_LIMITS.candidates)
+                            .flatMap((row) => {
+                            const p = typeof (row === null || row === void 0 ? void 0 : row.path) === "string"
+                                ? (0, document_contract_1.canonicalPointer)(row.path, context)
+                                : null;
+                            const wire = p &&
+                                path.join(context.wireRoot, path.relative(context.root, p));
+                            return p &&
+                                wire &&
+                                values.some((prefix) => wire === prefix || wire.startsWith(prefix + path.sep)) &&
+                                Number.isInteger(row.startLine) &&
+                                row.startLine > 0 &&
+                                Number.isInteger(row.endLine) &&
+                                row.endLine >= row.startLine &&
+                                Number.isFinite(row.score)
+                                ? [
+                                    Object.assign({ path: p, startLine: row.startLine, endLine: row.endLine, score: row.score }, pointerHash(row)),
+                                ]
+                                : [];
+                        });
+                        response = {
+                            state: "ready",
+                            generation: result.generation,
+                            root: context.root,
+                            store: context.store,
+                            matches,
+                            indexState: (0, document_contract_1.documentIndexState)(result.indexState),
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                response = (0, document_contract_1.documentFailure)(error.message);
+            }
+            let structuredContent = Object.assign(Object.assign({}, response), { contractVersion: document_contract_1.DOCUMENT_CONTRACT_VERSION, capabilities: document_contract_1.DOCUMENT_CAPABILITIES });
+            if (Buffer.byteLength(JSON.stringify(structuredContent)) >
+                document_contract_1.DOCUMENT_LIMITS.frameBytes - 4096)
+                structuredContent = Object.assign(Object.assign({}, (0, document_contract_1.documentFailure)("no_coverage")), { contractVersion: document_contract_1.DOCUMENT_CONTRACT_VERSION, capabilities: document_contract_1.DOCUMENT_CAPABILITIES });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: String((_d = structuredContent.state) !== null && _d !== void 0 ? _d : "search_unavailable"),
+                    },
+                ],
+                structuredContent,
+            };
+        });
+        server.registerTool("document_search_status", {
+            inputSchema: zod_1.z.object({
+                paths: zod_1.z.array(zod_1.z.string()).max(document_contract_1.DOCUMENT_LIMITS.paths),
+            }),
+            annotations: { readOnlyHint: true, destructiveHint: false },
+        }, (args, context) => call("document_search_status", args, context.mcpReq.signal));
+        server.registerTool("semantic_search", {
+            inputSchema: zod_1.z.object({
+                query: zod_1.z.string().min(1).max(document_contract_1.DOCUMENT_LIMITS.query),
+                prefixes: zod_1.z.array(zod_1.z.string()).min(1).max(document_contract_1.DOCUMENT_LIMITS.prefixes),
+            }),
+            annotations: { readOnlyHint: true, destructiveHint: false },
+        }, (args, context) => call("semantic_search", args, context.mcpReq.signal));
+        return server;
+    }, {
+        transport,
+        legacy: "serve",
+        onerror: () => {
+            /* Never retain query-bearing diagnostics. */
+        },
+    });
+}
+function pointerHash(row) {
+    return row.hashAlgorithm === "sha256-bytes" &&
+        typeof row.hash === "string" &&
+        /^[a-f0-9]{64}$/.test(row.hash)
+        ? { hash: row.hash, hashAlgorithm: "sha256-bytes" }
+        : {};
+}

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

@@ -845,6 +845,19 @@ class VectorDB {
             return table;
         });
     }
+    /** Restricted reads must use the daemon connection without creating/evolving a table. */
+    existingTableForRead() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.db)
+                throw new Error("store_unavailable");
+            try {
+                return yield this.db.openTable(TABLE_NAME);
+            }
+            catch (_a) {
+                throw new Error("store_unavailable");
+            }
+        });
+    }
     openExistingTableUnsafe() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield this.getDb();

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

@@ -106,7 +106,7 @@ function assertResourceSnapshot(snapshot, chargedMb, budgetMb, now = Date.now(),
 class ResourceBudget {
     constructor(overrides = {}) {
         this.deps = Object.assign({ root: path.join(config_1.PATHS.sharedRoot, "resource-budget"), platform: process.platform, pid: process.pid, now: Date.now, sample: (extraPids = []) => {
-                const records = this.readRecords();
+                const records = this.readExistingRecords();
                 return (0, host_resource_1.sampleHostResources)([...records.map((r) => r.pid), ...extraPids], this.deps.samplerOverrides, records.flatMap((r) => (r.groupPid ? [r.groupPid] : [])));
             }, signal: (pid) => process.kill(pid, 0), policy: host_guard_policy_1.hostGuardPolicy, requireClientRegistration: true, samplerOverrides: {}, sampleMaxAgeMs: 5000, criticalSample: host_guard_policy_1.sampleCriticalPressure, quarantine: autostart_1.daemonStartDeniedReason, latch: safety_latch_1.latchSafetyStop, processStart: () => (0, node_child_process_1.execFileSync)("ps", ["-p", String(process.pid), "-o", "lstart="], {
                 encoding: "utf8",
@@ -147,6 +147,21 @@ class ResourceBudget {
             release();
         }
     }
+    /** Existing-only reads may encounter a critical-only home with no ledger. */
+    readExistingRecords() {
+        let stat;
+        try {
+            stat = fs.lstatSync(this.deps.root);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new ResourceAdmissionError("unverified resource budget directory");
+        return this.readRecords();
+    }
     readRecords() {
         const entries = fs.readdirSync(this.deps.root);
         if (entries.some((name) => name.endsWith(".tmp")))
@@ -308,6 +323,19 @@ class ResourceBudget {
             },
         };
     }
+    /** Read-only admission for existing inference. 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;
+        const records = this.readExistingRecords();
+        const snapshot = this.deps.sample();
+        assertResourceSnapshot(snapshot, this.charge(snapshot, records), resolveResourceBudgetMb(), this.deps.now(), this.deps.sampleMaxAgeMs);
+        if (this.deps.quarantine())
+            throw new ResourceAdmissionError("host containment");
+        return snapshot;
+    }
     check(requiredPid) {
         if (this.deps.platform !== "darwin")
             return null;

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

@@ -145,14 +145,19 @@ class GraniteModel {
         }
         return vectors;
     }
-    runBatch(texts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    runBatch(texts_1) {
+        return __awaiter(this, arguments, void 0, function* (texts, existingOnly = false) {
             var _a;
             var _b, _c;
             // Lazy-load: in the normal path MLX/GPU handles dense embedding and this
             // ONNX model is never used, so we avoid paying its resident cost in every
             // worker. load() is idempotent and only runs on the first fallback batch.
-            yield this.load();
+            if (existingOnly) {
+                if (!this.isReady())
+                    throw new Error("embedding_unavailable");
+            }
+            else
+                yield this.load();
             if (!this.session || !this.tokenizer)
                 return [];
             const encoded = yield this.tokenizer(texts, {