grepmax 0.26.27 → 0.26.30

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

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Daemon-side handlers for the `vector.*` read verbs — the two commands whose
+ * store work is a vector scan rather than a row select.
+ *
+ * Both ship the *analysed* answer, never the vectors:
+ *
+ * - `vector.similar` runs the source-chunk lookup, `configureAnnVectorQuery`,
+ *   `table.vectorSearch`, and the self/threshold filter, and returns the ranked
+ *   chunks. The 384-float source vector never crosses the socket.
+ * - `vector.surprises` runs `analyzeSurprisingConnections` and returns the
+ *   summary plus the findings the caller will actually print. The raw `pairs`
+ *   array is dropped: nothing renders it, and it is the largest field by far.
+ *
+ * As in rows-handler.ts, each `run*` function is the single implementation both
+ * the verb and the command's in-process fallback call, so the two paths cannot
+ * produce different output.
+ */
+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.runSimilar = runSimilar;
+exports.handleVectorSimilar = handleVectorSimilar;
+exports.runSurprises = runSurprises;
+exports.handleVectorSurprises = handleVectorSurprises;
+exports.registerVectorVerbs = registerVectorVerbs;
+const surprising_connections_1 = require("../analysis/surprising-connections");
+const ann_config_1 = require("../store/ann-config");
+const arrow_1 = require("../utils/arrow");
+const filter_builder_1 = require("../utils/filter-builder");
+const path_containment_1 = require("../utils/path-containment");
+const scope_filter_1 = require("../utils/scope-filter");
+const read_verbs_1 = require("./read-verbs");
+const rows_handler_1 = require("./rows-handler");
+function runSimilar(deps, req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!deps.vectorDb)
+            throw new rows_handler_1.ReadVerbError("daemon not ready");
+        (_a = deps.touchActivity) === null || _a === void 0 ? void 0 : _a.call(deps);
+        const table = yield deps.vectorDb.ensureTable();
+        const sourceSelect = ["vector", "path", "defined_symbols", "start_line"];
+        const sourceRows = yield table
+            .query()
+            .select(sourceSelect)
+            .where(req.absPath !== undefined
+            ? `path = '${(0, filter_builder_1.escapeSqlString)(req.absPath)}'`
+            : `array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)((_b = req.symbol) !== null && _b !== void 0 ? _b : "")}') AND ${(0, filter_builder_1.pathStartsWith)(`${req.projectRoot}/`)}`)
+            .limit(1)
+            .toArray();
+        if (sourceRows.length === 0)
+            return { status: "not-found" };
+        const source = sourceRows[0];
+        const sourceVector = source.vector;
+        const sourcePath = String(source.path || "");
+        if (!sourceVector || sourceVector.length === 0)
+            return { status: "no-vector" };
+        const pathScope = (0, scope_filter_1.buildScopeWhere)(req.scope);
+        const results = yield (0, ann_config_1.configureAnnVectorQuery)(table.vectorSearch(sourceVector))
+            .select([
+            "path",
+            "start_line",
+            "end_line",
+            "defined_symbols",
+            "role",
+            "content",
+            "_distance",
+        ])
+            .where(pathScope)
+            .limit(req.limit + 5) // fetch extra to account for self-filtering
+            .toArray();
+        // Filter out self and apply threshold
+        const filtered = results.filter((raw) => {
+            const r = raw;
+            if (r.path === sourcePath && r.start_line === source.start_line)
+                return false;
+            if (req.threshold > 0) {
+                // LanceDB returns L2 distance; convert to similarity
+                const sim = 1 / (1 + (Number(r._distance) || 0));
+                if (sim < req.threshold)
+                    return false;
+            }
+            return true;
+        });
+        // `content` is selected (keeping the query identical) but never rendered, so
+        // it is dropped here rather than shipped.
+        return {
+            status: "ok",
+            results: filtered.map((raw) => {
+                var _a, _b, _c, _d, _e;
+                const r = raw;
+                return {
+                    path: String((_a = r.path) !== null && _a !== void 0 ? _a : ""),
+                    start_line: Number((_b = r.start_line) !== null && _b !== void 0 ? _b : 0),
+                    end_line: Number((_c = r.end_line) !== null && _c !== void 0 ? _c : 0),
+                    defined_symbols: (0, arrow_1.toArr)(r.defined_symbols),
+                    role: String((_d = r.role) !== null && _d !== void 0 ? _d : ""),
+                    _distance: Number((_e = r._distance) !== null && _e !== void 0 ? _e : 0),
+                };
+            }),
+        };
+    });
+}
+function handleVectorSimilar(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, rows_handler_1.asReadVerbResponse)(() => __awaiter(this, void 0, void 0, function* () {
+            const projectRoot = (0, rows_handler_1.assertReadableProject)(payload.projectRoot);
+            const scope = (0, rows_handler_1.resolveWireScope)(projectRoot, payload.scope);
+            const absPath = typeof payload.absPath === "string" && payload.absPath
+                ? (0, path_containment_1.resolveContainedPath)(projectRoot, payload.absPath)
+                : undefined;
+            const symbol = typeof payload.symbol === "string" && payload.symbol
+                ? payload.symbol
+                : undefined;
+            if (!absPath && !symbol)
+                throw new rows_handler_1.ReadVerbError("missing target");
+            const result = yield runSimilar(deps, {
+                projectRoot,
+                absPath,
+                symbol,
+                scope,
+                limit: (0, rows_handler_1.clampInt)(payload.limit, 5, 1, 25),
+                threshold: typeof payload.threshold === "number" &&
+                    Number.isFinite(payload.threshold)
+                    ? payload.threshold
+                    : 0,
+            });
+            return Object.assign({ ok: true }, result);
+        }));
+    });
+}
+function runSurprises(deps, req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!deps.vectorDb)
+            throw new rows_handler_1.ReadVerbError("daemon not ready");
+        (_a = deps.touchActivity) === null || _a === void 0 ? void 0 : _a.call(deps);
+        const table = yield deps.vectorDb.ensureTable();
+        const result = yield (0, surprising_connections_1.analyzeSurprisingConnections)(table, req.projectRoot, req.options);
+        // Both formatters use only `summary` and `findings.slice(0, top)`, plus
+        // `findings.length === 0`. Trimming to `top` here preserves both and keeps
+        // `pairs` (the bulk of the object) off the wire entirely.
+        return {
+            summary: result.summary,
+            findings: result.findings.slice(0, req.top),
+        };
+    });
+}
+function handleVectorSurprises(deps, payload) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (0, rows_handler_1.asReadVerbResponse)(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const projectRoot = (0, rows_handler_1.assertReadableProject)(payload.projectRoot);
+            const raw = ((_a = payload.options) !== null && _a !== void 0 ? _a : {});
+            const toPrefixList = (value) => {
+                if (!Array.isArray(value) || value.length === 0)
+                    return undefined;
+                // Validated here rather than trusted: these reach resolveScope, which
+                // builds the WHERE clause the scan runs under.
+                return value.map((v) => (0, path_containment_1.resolveContainedPath)(projectRoot, String(v)));
+            };
+            const result = yield runSurprises(deps, {
+                projectRoot,
+                options: {
+                    sample: (0, rows_handler_1.clampInt)(raw.sample, surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.sample, 1, 10000),
+                    neighbors: (0, rows_handler_1.clampInt)(raw.neighbors, surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.neighbors, 1, 200),
+                    dirDepth: (0, rows_handler_1.clampInt)(raw.dirDepth, surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.dirDepth, 1, 20),
+                    minSimilarity: typeof raw.minSimilarity === "number" &&
+                        Number.isFinite(raw.minSimilarity) &&
+                        raw.minSimilarity >= 0
+                        ? raw.minSimilarity
+                        : surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.minSimilarity,
+                    maxRows: (0, rows_handler_1.clampInt)(raw.maxRows, surprising_connections_1.DEFAULT_SURPRISE_OPTIONS.maxRows, 1, surprising_connections_1.MAX_SURPRISE_ROWS),
+                    includeTests: Boolean(raw.includeTests),
+                    includeEval: Boolean(raw.includeEval),
+                    in: toPrefixList(raw.in),
+                    exclude: toPrefixList(raw.exclude),
+                },
+                top: (0, rows_handler_1.clampInt)(payload.top, 20, 1, 100),
+            });
+            return Object.assign({ ok: true }, result);
+        }));
+    });
+}
+// --- Registration -----------------------------------------------------------
+/** Called from `Daemon.start()`; see registerRowsVerbs for why not at import. */
+function registerVectorVerbs() {
+    (0, read_verbs_1.registerReadVerbs)({
+        "vector.similar": (payload, ctx) => handleVectorSimilar(ctx.daemon.storeReadDeps(), payload),
+        "vector.surprises": (payload, ctx) => handleVectorSurprises(ctx.daemon.storeReadDeps(), payload),
+    });
+}

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 {