grepmax 0.26.28 → 0.26.32

package/dist/lib/daemon/ipc-handler.js

@@ -150,20 +150,28 @@ function handleCommand(daemon, cmd, conn) {
                         capabilities: {
                             exclusiveGenerationRebuild: exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL,
                             readVerbs: read_verbs_1.READ_VERBS_PROTOCOL,
+                            // `watch`/`unwatch` accept holder/pid/ttlMs. A daemon without this
+                            // treats `unwatch` as unwatch-for-everyone, so clients releasing a
+                            // single lease must check it first.
+                            watchLeases: 1,
                         },
                     };
                 case "watch": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    yield daemon.watchProject(root);
+                    yield daemon.requestWatch(root, {
+                        holder: typeof cmd.holder === "string" ? cmd.holder : undefined,
+                        pid: typeof cmd.pid === "number" ? cmd.pid : undefined,
+                        ttlMs: typeof cmd.ttlMs === "number" ? cmd.ttlMs : undefined,
+                    });
                     return { ok: true, pid: process.pid };
                 }
                 case "unwatch": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    yield daemon.unwatchProject(root);
+                    yield daemon.releaseWatch(root, typeof cmd.holder === "string" ? cmd.holder : undefined);
                     return { ok: true };
                 }
                 case "status":
@@ -172,6 +180,7 @@ function handleCommand(daemon, cmd, conn) {
                         pid: process.pid,
                         uptime: daemon.uptime(),
                         projects: daemon.listProjects(),
+                        leases: daemon.listWatchLeases(),
                         diskPressure: daemon.getDiskPressure(),
                         mlx: daemon.getMlxStatus(),
                     };
@@ -304,6 +313,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.addProject(root, conn));
                     return null;
                 }
@@ -311,6 +321,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.ensureProject(root, conn));
                     return null;
                 }
@@ -318,6 +329,7 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
+                    daemon.leaseForCli(root);
                     startStreaming(conn, () => daemon.indexProject(root, conn, {
                         reset: !!cmd.reset,
                         dryRun: !!cmd.dryRun,
@@ -385,8 +397,11 @@ function handleCommand(daemon, cmd, conn) {
                     const ac = new AbortController();
                     const onClose = () => ac.abort();
                     conn.on("close", onClose);
+                    const name = String(cmd.cmd);
                     try {
-                        return yield daemon.runSharedOperation(String(cmd.cmd), ac.signal, (signal) => verb(cmd, { daemon, conn, signal }));
+                        // Heavy verbs queue on a global gate before admission; see
+                        // HEAVY_READ_VERBS in read-verbs.ts.
+                        return yield (0, read_verbs_1.runReadVerb)(name, ac.signal, () => daemon.runSharedOperation(name, ac.signal, (signal) => verb(cmd, { daemon, conn, signal })));
                     }
                     finally {
                         conn.off("close", onClose);

package/dist/lib/daemon/read-verbs.js

@@ -20,12 +20,16 @@
  * so `ipc-handler` tests can drive them with a fake `Daemon`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.READ_VERBS_PROTOCOL = void 0;
+exports.heavyReadGate = exports.DEFAULT_HEAVY_READ_CONCURRENCY = exports.HEAVY_READ_VERBS = exports.READ_VERBS_PROTOCOL = void 0;
 exports.registerReadVerbs = registerReadVerbs;
 exports.getReadVerb = getReadVerb;
 exports.readVerbNames = readVerbNames;
+exports.resolveHeavyReadConcurrency = resolveHeavyReadConcurrency;
+exports.isHeavyReadVerb = isHeavyReadVerb;
+exports.runReadVerb = runReadVerb;
 exports.clearReadVerbs = clearReadVerbs;
 exports.registerGraphVerbs = registerGraphVerbs;
+const async_semaphore_1 = require("../utils/async-semaphore");
 const graph_handler_1 = require("./graph-handler");
 /** Bumped when the verb wire shapes change incompatibly. */
 exports.READ_VERBS_PROTOCOL = 1;
@@ -50,6 +54,53 @@ function getReadVerb(name) {
 function readVerbNames() {
     return [...registry.keys()].sort();
 }
+// ---------------------------------------------------------------------------
+// Heavy-verb admission.
+//
+// `runSharedOperation` only tracks a verb; it never limits how many run. These
+// verbs each scan a large slice of the table (tens to hundreds of thousands of
+// rows, or one vector search per sampled anchor), and their Arrow buffers sit
+// in native memory until the answer is built. With one MCP session per Claude
+// Code window, N sessions asking at once meant N such scans resident together.
+// They now share a small global semaphore; everything else stays unbounded,
+// because point lookups (`graph.resolve`, `rows.locate`, ...) are cheap and
+// must not queue behind an audit.
+//
+// A queued request waits *before* `runSharedOperation` admits it (see
+// `runReadVerb`), so an exclusive rebuild does not have to sit behind scans
+// that have not started yet, and a client that disconnects while queued
+// leaves without ever touching the store.
+// ---------------------------------------------------------------------------
+exports.HEAVY_READ_VERBS = new Set([
+    "graph.audit", // up to AUDIT_ROW_LIMIT rows with symbol arrays
+    "graph.dead", // whole caller set
+    "graph.risk", // up to MAX_RISK_SYMBOLS x three content scans
+    "graph.subgraph", // per-file symbol scans over up to MAX_SUBGRAPH_FILES
+    "graph.trace", // multi-hop caller/callee expansion
+    "rows.project", // up to 200k rows with two symbol-array columns
+    "vector.similar", // vector search plus content
+    "vector.surprises", // up to 100k-row scan plus one search per anchor
+]);
+exports.DEFAULT_HEAVY_READ_CONCURRENCY = 2;
+/** `GMAX_HEAVY_READ_CONCURRENCY`, or the default when unset or not a positive integer. */
+function resolveHeavyReadConcurrency(raw = process.env.GMAX_HEAVY_READ_CONCURRENCY) {
+    const n = Number(raw);
+    return raw !== undefined && Number.isInteger(n) && n >= 1
+        ? n
+        : exports.DEFAULT_HEAVY_READ_CONCURRENCY;
+}
+exports.heavyReadGate = new async_semaphore_1.AsyncSemaphore(resolveHeavyReadConcurrency());
+function isHeavyReadVerb(name) {
+    return typeof name === "string" && exports.HEAVY_READ_VERBS.has(name);
+}
+/**
+ * Admission wrapper `ipc-handler` puts around a verb's shared operation: heavy
+ * verbs wait for a gate slot first (abortable through `signal`), light verbs
+ * run straight through.
+ */
+function runReadVerb(name, signal, run, gate = exports.heavyReadGate) {
+    return isHeavyReadVerb(name) ? gate.run(signal, run) : run();
+}
 /** Test hook: drop every registration. */
 function clearReadVerbs() {
     registry.clear();

package/dist/lib/daemon/search-handler.js

@@ -76,10 +76,13 @@ function handleDaemonSearch(deps, payload, signal) {
         if (!deps.processors.has(root)) {
             // A full index (--reset) or the initial index removes/defers the
             // processor while (re)building. The partial index is still queryable, so
-            // answer the search and flag it partial (below) rather than erroring —
-            // only truly-unwatched, not-indexing projects get "not watched".
-            const indexingNow = deps.indexProgress.has(root) || ((_c = (0, project_registry_1.getProject)(root)) === null || _c === void 0 ? void 0 : _c.status) === "pending";
-            if (!indexingNow) {
+            // answer the search and flag it partial (below) rather than erroring.
+            // An indexed project nobody holds a watch lease on is served from its
+            // last-synced vectors — watching is per session now, not a precondition
+            // for reading. Only unknown, never-indexed roots get "not watched".
+            const status = (_c = (0, project_registry_1.getProject)(root)) === null || _c === void 0 ? void 0 : _c.status;
+            const indexingNow = deps.indexProgress.has(root) || status === "pending";
+            if (!indexingNow && status !== "indexed") {
                 return {
                     ok: false,
                     error: "project not watched",

package/dist/lib/daemon/watch-leases.js

@@ -0,0 +1,179 @@
+"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.WatchLeases = exports.MAX_LEASE_TTL_MS = exports.DEFAULT_LEASE_TTL_MS = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+exports.DEFAULT_LEASE_TTL_MS = 30 * 60 * 1000;
+/** Upper bound on a requested TTL — a lease must not outlive its holder by days. */
+exports.MAX_LEASE_TTL_MS = 12 * 60 * 60 * 1000;
+function defaultIsPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM: the process exists but belongs to someone else.
+        return err.code === "EPERM";
+    }
+}
+class WatchLeases {
+    constructor(file, opts = {}) {
+        var _a, _b;
+        this.file = file;
+        this.leases = new Map();
+        this.now = (_a = opts.now) !== null && _a !== void 0 ? _a : Date.now;
+        this.isPidAlive = (_b = opts.isPidAlive) !== null && _b !== void 0 ? _b : defaultIsPidAlive;
+    }
+    static key(root, holder) {
+        return `${root}\0${holder}`;
+    }
+    /** Take or renew a lease. Returns true if the root was not wanted before. */
+    acquire(root, req) {
+        const wasWanted = this.isWanted(root);
+        const ttl = Math.min(Math.max(req.ttlMs, 1000), exports.MAX_LEASE_TTL_MS);
+        this.leases.set(WatchLeases.key(root, req.holder), {
+            root,
+            holder: req.holder,
+            pid: req.pid,
+            expiresAt: this.now() + ttl,
+        });
+        this.persist();
+        return !wasWanted;
+    }
+    /** Drop one holder's lease, or every lease on the root when holder is omitted. */
+    release(root, holder) {
+        let changed = false;
+        for (const [key, lease] of this.leases) {
+            if (lease.root !== root)
+                continue;
+            if (holder !== undefined && lease.holder !== holder)
+                continue;
+            this.leases.delete(key);
+            changed = true;
+        }
+        if (changed)
+            this.persist();
+    }
+    isLive(lease) {
+        if (lease.expiresAt <= this.now())
+            return false;
+        if (lease.pid !== undefined && !this.isPidAlive(lease.pid))
+            return false;
+        return true;
+    }
+    isWanted(root) {
+        for (const lease of this.leases.values()) {
+            if (lease.root === root && this.isLive(lease))
+                return true;
+        }
+        return false;
+    }
+    /** Drop dead leases. Returns roots that were wanted before and are not now. */
+    sweep() {
+        // Every stored lease was live when last swept or acquired, so the stored
+        // roots — not the currently-live ones — are what "wanted before" means.
+        const before = new Set([...this.leases.values()].map((l) => l.root));
+        let changed = false;
+        for (const [key, lease] of this.leases) {
+            if (!this.isLive(lease)) {
+                this.leases.delete(key);
+                changed = true;
+            }
+        }
+        if (!changed)
+            return [];
+        this.persist();
+        const after = this.wantedRoots();
+        return [...before].filter((root) => !after.has(root));
+    }
+    wantedRoots() {
+        const roots = new Set();
+        for (const lease of this.leases.values()) {
+            if (this.isLive(lease))
+                roots.add(lease.root);
+        }
+        return roots;
+    }
+    /** Live leases, for `gmax status`. */
+    list() {
+        return [...this.leases.values()].filter((lease) => this.isLive(lease));
+    }
+    load() {
+        if (!this.file)
+            return;
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(this.file, "utf-8"));
+        }
+        catch (_a) {
+            return;
+        }
+        if (!Array.isArray(raw))
+            return;
+        for (const entry of raw) {
+            if (!entry ||
+                typeof entry.root !== "string" ||
+                typeof entry.holder !== "string" ||
+                typeof entry.expiresAt !== "number") {
+                continue;
+            }
+            const lease = {
+                root: entry.root,
+                holder: entry.holder,
+                pid: typeof entry.pid === "number" ? entry.pid : undefined,
+                expiresAt: Math.min(entry.expiresAt, this.now() + exports.MAX_LEASE_TTL_MS),
+            };
+            if (this.isLive(lease)) {
+                this.leases.set(WatchLeases.key(lease.root, lease.holder), lease);
+            }
+        }
+    }
+    persist() {
+        if (!this.file)
+            return;
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            const tmp = `${this.file}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify([...this.leases.values()]));
+            fs.renameSync(tmp, this.file);
+        }
+        catch (_a) {
+            // Persistence only shortens the gap after a restart; the next renewal
+            // re-establishes the lease either way.
+        }
+    }
+}
+exports.WatchLeases = WatchLeases;

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

@@ -59,6 +59,11 @@ const MAX_BATCH_SIZE = 50;
 // Pool priority cannot preempt an active processFile, so keep one worker free
 // for latency-sensitive encodeQuery/rerank work during indexing bursts.
 const DEFAULT_BATCH_CONCURRENCY = Math.max(1, config_1.CONFIG.WORKER_THREADS - 1);
+// Files per concurrent task slot. A watcher batch of a handful of small files
+// finishes in a second or two on one worker, so fanning it out only makes the
+// pool cold-spawn workers (each loads the models, ~1 GB) that are reaped
+// unused 60s later. Scale fan-out with the batch instead.
+const FILES_PER_BATCH_SLOT = 4;
 class ProjectBatchProcessor {
     constructor(opts) {
         var _a, _b, _c;
@@ -436,6 +441,7 @@ class ProjectBatchProcessor {
                         }
                     }
                 });
+                const batchConcurrency = Math.min(this.concurrency, Math.max(1, Math.ceil(batch.size / FILES_PER_BATCH_SLOT)));
                 const activeTasks = [];
                 const schedule = (task) => __awaiter(this, void 0, void 0, function* () {
                     const taskPromise = task();
@@ -446,7 +452,7 @@ class ProjectBatchProcessor {
                             activeTasks.splice(index, 1);
                     };
                     void taskPromise.then(removeActiveTask, removeActiveTask);
-                    if (activeTasks.length >= this.concurrency) {
+                    if (activeTasks.length >= batchConcurrency) {
                         yield Promise.race(activeTasks);
                     }
                 });

package/dist/lib/index/watcher.js

@@ -96,6 +96,10 @@ exports.WATCHER_IGNORE_GLOBS = [
     // "**/<name>" ignores the directory entry itself, "**/<name>/**" its contents.
     ...IGNORED_DIR_NAMES.flatMap((name) => [`**/${name}`, `**/${name}/**`]),
     "**/*.tmp.*", // editor atomic save artifacts
+    // Atomic-save temp files named `.!<pid>!<name>` (e.g. `.!8903!dotmd.md`).
+    // picomatch treats `!` as a literal unless it leads the pattern or opens
+    // an `!(...)` extglob, so this matches only that shape, at any depth.
+    "**/.!*!*",
     "**/*.sb-*", // Xcode swap files
     // Codegen output never reaches the index (file policy drops it), so don't
     // let it reach the watcher either — it is the dominant source of FSEvents

package/dist/lib/search/pagerank.js

@@ -42,12 +42,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGERANK_MEMORY_CACHE_MAX = exports.PAGERANK_ROW_LIMIT = void 0;
 exports.computePageRank = computePageRank;
 exports.buildGraphFromDb = buildGraphFromDb;
 exports.writeDiskCache = writeDiskCache;
 exports.loadOrComputePageRank = loadOrComputePageRank;
 exports.pageRankBoostForSymbols = pageRankBoostForSymbols;
 exports._clearMemoryCacheForTests = _clearMemoryCacheForTests;
+exports._memoryCacheKeysForTests = _memoryCacheKeysForTests;
 exports._cachePathForTests = _cachePathForTests;
 const crypto = __importStar(require("node:crypto"));
 const fs = __importStar(require("node:fs"));
@@ -58,7 +60,51 @@ const DEFAULT_DAMPING = 0.85;
 const DEFAULT_MAX_ITER = 50;
 const DEFAULT_TOL = 1e-6;
 const DEFAULT_TTL_MS = 60 * 60 * 1000;
+/**
+ * Row cap for the graph scan. Matches `graph.audit`'s AUDIT_ROW_LIMIT: the
+ * largest indexed project holds ~270k chunks, so this never truncates a real
+ * project, but a runaway prefix (a home directory, a monorepo root) can no
+ * longer pull millions of symbol-array rows into daemon memory at once. A
+ * truncated scan ranks the symbols it saw; the ranking is a search boost, not
+ * an answer, so a partial graph degrades gracefully.
+ */
+exports.PAGERANK_ROW_LIMIT = 500000;
+/**
+ * Score maps stay in the daemon for its lifetime, one per scoped prefix a
+ * search has used (`--in` makes those open-ended). Keep the most recently
+ * used few; each is a Map over every defined symbol in its scope.
+ */
+exports.PAGERANK_MEMORY_CACHE_MAX = 8;
+// Map iteration order is insertion order, so re-inserting on a hit makes the
+// first key the least recently used.
 const memoryCache = new Map();
+// Concurrent searches on a cold prefix share one scan instead of each running
+// their own.
+const inFlight = new Map();
+function memoryGet(pathPrefix) {
+    const entry = memoryCache.get(pathPrefix);
+    if (!entry)
+        return undefined;
+    memoryCache.delete(pathPrefix);
+    if (Date.now() - entry.computedAt >= getTtlMs())
+        return undefined;
+    memoryCache.set(pathPrefix, entry);
+    return entry;
+}
+function memorySet(pathPrefix, entry) {
+    memoryCache.delete(pathPrefix);
+    memoryCache.set(pathPrefix, entry);
+    const ttl = getTtlMs();
+    const now = Date.now();
+    for (const [key, value] of memoryCache) {
+        if (now - value.computedAt >= ttl)
+            memoryCache.delete(key);
+    }
+    while (memoryCache.size > exports.PAGERANK_MEMORY_CACHE_MAX) {
+        const oldest = memoryCache.keys().next().value;
+        memoryCache.delete(oldest);
+    }
+}
 function computePageRank(graph, damping = DEFAULT_DAMPING, maxIter = DEFAULT_MAX_ITER, tol = DEFAULT_TOL) {
     const N = graph.nodes.length;
     const result = new Map();
@@ -148,6 +194,7 @@ function buildGraphFromDb(db, pathPrefix) {
             .query()
             .select(["defined_symbols", "referenced_symbols"])
             .where((0, filter_builder_1.pathStartsWith)(prefix))
+            .limit(exports.PAGERANK_ROW_LIMIT)
             .toArray();
         const nodes = new Set();
         const edges = new Map();
@@ -224,28 +271,38 @@ function writeDiskCache(pathPrefix, scores) {
 }
 function loadOrComputePageRank(db, pathPrefix) {
     return __awaiter(this, void 0, void 0, function* () {
-        const mem = memoryCache.get(pathPrefix);
-        if (mem && Date.now() - mem.computedAt < getTtlMs()) {
+        const mem = memoryGet(pathPrefix);
+        if (mem)
             return { scores: mem.scores, max: mem.max };
-        }
-        const disk = readDiskCache(pathPrefix);
-        if (disk) {
-            memoryCache.set(pathPrefix, disk);
-            return { scores: disk.scores, max: disk.max };
-        }
-        const graph = yield buildGraphFromDb(db, pathPrefix);
-        const scores = computePageRank(graph);
-        let max = 0;
-        for (const v of scores.values())
-            if (v > max)
-                max = v;
-        const entry = { scores, max, computedAt: Date.now() };
-        memoryCache.set(pathPrefix, entry);
+        const pending = inFlight.get(pathPrefix);
+        if (pending)
+            return pending;
+        const task = (() => __awaiter(this, void 0, void 0, function* () {
+            const disk = readDiskCache(pathPrefix);
+            if (disk) {
+                memorySet(pathPrefix, disk);
+                return { scores: disk.scores, max: disk.max };
+            }
+            const graph = yield buildGraphFromDb(db, pathPrefix);
+            const scores = computePageRank(graph);
+            let max = 0;
+            for (const v of scores.values())
+                if (v > max)
+                    max = v;
+            memorySet(pathPrefix, { scores, max, computedAt: Date.now() });
+            try {
+                writeDiskCache(pathPrefix, scores);
+            }
+            catch (_a) { }
+            return { scores, max };
+        }))();
+        inFlight.set(pathPrefix, task);
         try {
-            writeDiskCache(pathPrefix, scores);
+            return yield task;
+        }
+        finally {
+            inFlight.delete(pathPrefix);
         }
-        catch (_a) { }
-        return { scores, max };
     });
 }
 function pageRankBoostForSymbols(symbols, scores, max) {
@@ -261,6 +318,10 @@ function pageRankBoostForSymbols(symbols, scores, max) {
 }
 function _clearMemoryCacheForTests() {
     memoryCache.clear();
+    inFlight.clear();
+}
+function _memoryCacheKeysForTests() {
+    return [...memoryCache.keys()];
 }
 function _cachePathForTests(pathPrefix) {
     return cachePathFor(pathPrefix);

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

@@ -187,11 +187,33 @@ const COMPACTION_MIN_INTERVAL_MS = 30 * 60 * 1000;
  * so a store that cannot be improved stops paying for the attempt.
  */
 const COMPACTION_MAX_INTERVAL_MS = 6 * 60 * 60 * 1000;
+/**
+ * Bounds for LanceDB's per-connection caches.
+ *
+ * `lancedb.connect()` without a Session gets a 6 GB index cache and a 1 GB
+ * metadata cache, and a connection lives as long as the daemon. On a 48 GB host
+ * that was already swapping, the daemon reached a 4 GB footprint (9.6 GB peak),
+ * almost all native malloc and invisible to the RSS-based recycle because most of
+ * it had been compressed or swapped. The whole on-disk index directory for a
+ * 430k-row store is ~650 MB, so 1 GB still holds every index; the metadata cache
+ * only needs the latest manifests, not every retained version.
+ */
+const LANCE_INDEX_CACHE_MB = envMb("GMAX_LANCE_INDEX_CACHE_MB", 1024);
+const LANCE_METADATA_CACHE_MB = envMb("GMAX_LANCE_METADATA_CACHE_MB", 256);
+function envMb(name, fallback) {
+    const parsed = Number(process.env[name]);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function createLanceSession() {
+    const mb = (n) => BigInt(n * 1024 * 1024);
+    return new lancedb.Session(mb(LANCE_INDEX_CACHE_MB), mb(LANCE_METADATA_CACHE_MB));
+}
 class VectorDB {
     constructor(lancedbDir, vectorDim, suppliedLease) {
         this.lancedbDir = lancedbDir;
         this.suppliedLease = suppliedLease;
         this.db = null;
+        this.session = null;
         this.closed = false;
         this.maintenanceRunning = false;
         this.maintenancePromise = null;
@@ -291,6 +313,16 @@ class VectorDB {
     }
     /** True iff a maintenance tick is currently running. Used by the daemon to
      *  defer idle shutdown so we don't tear down LanceDB mid-optimize. */
+    /** Bytes held by LanceDB's index + metadata caches (0 before first connect). */
+    cacheSizeBytes() {
+        var _a, _b;
+        try {
+            return Number((_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.sizeBytes()) !== null && _b !== void 0 ? _b : 0);
+        }
+        catch (_c) {
+            return 0;
+        }
+    }
     isMaintenanceActive() {
         return this.maintenancePromise !== null;
     }
@@ -324,7 +356,8 @@ class VectorDB {
             }
             if (!this.db) {
                 fs.mkdirSync(this.lancedbDir, { recursive: true });
-                this.db = yield lancedb.connect(this.lancedbDir);
+                this.session = createLanceSession();
+                this.db = yield lancedb.connect(this.lancedbDir, {}, this.session);
             }
             return this.db;
         });
@@ -1578,6 +1611,7 @@ class VectorDB {
                 }
             }
             this.db = null;
+            this.session = null;
             if (this.leasePromise) {
                 let lease = null;
                 try {