grepmax 0.26.39 → 0.26.41

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

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleDaemonSearch = handleDaemonSearch;
 const embedding_generation_1 = require("../index/embedding-generation");
+const index_state_footer_1 = require("../output/index-state-footer");
 const searcher_1 = require("../search/searcher");
 const retriever_1 = require("../skeleton/retriever");
 const project_registry_1 = require("../utils/project-registry");
@@ -55,7 +56,7 @@ const project_registry_1 = require("../utils/project-registry");
 function handleDaemonSearch(deps, payload, signal) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
-        var _e, _f;
+        var _e, _f, _g;
         const { vectorDb, workerPool } = deps;
         if (!vectorDb || !workerPool) {
             return { ok: false, error: "daemon not ready" };
@@ -116,11 +117,20 @@ function handleDaemonSearch(deps, payload, signal) {
         if ((_c = result.warnings) === null || _c === void 0 ? void 0 : _c.length)
             response.warnings = result.warnings;
         // Annotate partial results when the index is still catching up, so an
-        // agent can caveat or retry. Only attached when actually indexing (the
-        // formatter suppresses the settled case anyway).
+        // agent can caveat or retry. Settled failures remain visible too.
         const idx = deps.getIndexState(root);
-        if (idx.indexing)
-            response.indexState = idx;
+        response.indexState = idx;
+        for (const candidateRoot of roots) {
+            if (candidateRoot === root)
+                continue;
+            const health = (0, index_state_footer_1.formatIndexStateFooter)(deps.getIndexState(candidateRoot), {
+                agent: true,
+            });
+            if (health) {
+                (_f = response.warnings) !== null && _f !== void 0 ? _f : (response.warnings = []);
+                response.warnings.push(`${candidateRoot}: ${health}`);
+            }
+        }
         // --skeleton support: fetch per-file skeletons inline so the CLI doesn't
         // have to open its own VectorDB. getStoredSkeleton is a single LIMIT-1
         // lookup; cheap enough to call for the top N distinct paths.
@@ -131,7 +141,7 @@ function handleDaemonSearch(deps, payload, signal) {
             const seen = new Set();
             const skeletons = {};
             for (const chunk of result.data) {
-                const p = (_f = chunk.path) !== null && _f !== void 0 ? _f : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
+                const p = (_g = chunk.path) !== null && _g !== void 0 ? _g : (_d = chunk.metadata) === null || _d === void 0 ? void 0 : _d.path;
                 if (!p || seen.has(p))
                     continue;
                 seen.add(p);
@@ -142,7 +152,7 @@ function handleDaemonSearch(deps, payload, signal) {
                     if (sk)
                         skeletons[p] = sk;
                 }
-                catch (_g) {
+                catch (_h) {
                     // best-effort — drop the entry, keep the search result
                 }
             }
@@ -157,7 +167,7 @@ function handleDaemonSearch(deps, payload, signal) {
                 const builder = new GraphBuilder(vectorDb, root);
                 response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
             }
-            catch (_h) {
+            catch (_j) {
                 // best-effort — drop graph, keep results
             }
         }

package/dist/lib/daemon/watcher-manager.js

@@ -104,6 +104,10 @@ class WatcherManager {
         this.pollRecoveryTimers = new Map();
         this.recoveryTimeouts = new Map();
         this.lastOverflowMs = new Map();
+        this.lastWatcherErrorLogMs = new Map();
+        this.overflowCounts = new Map();
+        this.reconciledAt = new Map();
+        this.catchupDurations = new Map();
         this.lastCatchupEndMs = new Map();
         this.deferredCatchups = new Map();
         this.catchups = new Map();
@@ -111,6 +115,24 @@ class WatcherManager {
         this.terminalFailures = new Map();
         this.watchLifecycles = new Map();
     }
+    health(root) {
+        var _a;
+        var _b, _c;
+        return {
+            failedFiles: (_b = (_a = this.terminalFailures.get(root)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0,
+            degraded: this.isRootDegraded(root),
+            watcherMode: this.pollIntervals.has(root)
+                ? "polling"
+                : this.pendingOps.has(`recover:${root}`) ||
+                    this.deferredCatchups.has(root)
+                    ? "recovering"
+                    : "native",
+            catchupRunning: this.catchups.has(root),
+            lastReconciledAt: this.reconciledAt.get(root),
+            overflowCount: (_c = this.overflowCounts.get(root)) !== null && _c !== void 0 ? _c : 0,
+            catchupMs: this.catchupDurations.get(root),
+        };
+    }
     watchProject(root_1) {
         return __awaiter(this, arguments, void 0, function* (root, options = {}) {
             var _a, _b;
@@ -268,14 +290,20 @@ class WatcherManager {
                 this.deps.subscriptions.delete(root);
             }
             const sub = yield watcher.subscribe(root, (err, events) => {
-                var _a;
+                var _a, _b;
                 if (err) {
-                    console.error(`[daemon:${name}] Watcher error:`, err);
+                    this.overflowCounts.set(root, ((_a = this.overflowCounts.get(root)) !== null && _a !== void 0 ? _a : 0) + 1);
+                    const now = Date.now();
+                    if (!this.lastWatcherErrorLogMs.has(root) ||
+                        now - this.lastWatcherErrorLogMs.get(root) >= 60000) {
+                        this.lastWatcherErrorLogMs.set(root, now);
+                        console.error(`[daemon:${name}] Watcher error (total=${this.overflowCounts.get(root)}):`, err);
+                    }
                     this.recoverWatcher(root, processor);
                     return;
                 }
                 // Only reset fail counter after sustained health (5min since last overflow)
-                const lastOverflow = (_a = this.lastOverflowMs.get(root)) !== null && _a !== void 0 ? _a : 0;
+                const lastOverflow = (_b = this.lastOverflowMs.get(root)) !== null && _b !== void 0 ? _b : 0;
                 if (Date.now() - lastOverflow > 5 * 60 * 1000) {
                     this.watcherFailCount.delete(root);
                 }
@@ -490,6 +518,7 @@ class WatcherManager {
             var _a, e_1, _b, _c;
             var _d;
             var _e;
+            const scanStart = Date.now();
             const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
             const metaCache = this.deps.getMetaCache();
             const vectorDb = this.deps.getVectorDb();
@@ -641,7 +670,11 @@ class WatcherManager {
                     parts.push(`${purged} deleted`);
                 console.log(`[daemon:${path.basename(root)}] Catchup: ${parts.join(", ")} file(s) while offline`);
             }
-            this.lastCatchupEndMs.set(root, Date.now());
+            const ended = Date.now();
+            this.lastCatchupEndMs.set(root, ended);
+            this.catchupDurations.set(root, ended - scanStart);
+            if (complete)
+                this.reconciledAt.set(root, ended);
             return complete;
         });
     }

package/dist/lib/graph/graph-builder.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphBuilder = void 0;
 const languages_1 = require("../core/languages");
+const arrow_1 = require("../utils/arrow");
 const filter_builder_1 = require("../utils/filter-builder");
 const query_timeout_1 = require("../utils/query-timeout");
 const callsites_1 = require("./callsites");
@@ -118,19 +119,43 @@ class GraphBuilder {
      */
     getCallees(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
             // Find the definition of the symbol
             const rows = yield table
                 .query()
-                .select(["referenced_symbols"])
+                .select([
+                "path",
+                "referenced_symbols",
+                "member_referenced_symbols",
+                "content",
+            ])
                 .where(this.scopeWhere(`array_contains(defined_symbols, '${escaped}')`))
                 .limit(1)
                 .toArray();
             if (rows.length === 0)
                 return [];
             const record = rows[0];
-            return record.referenced_symbols || [];
+            const memberNames = (0, arrow_1.toArr)(record.member_referenced_symbols);
+            const content = String((_a = record.content) !== null && _a !== void 0 ? _a : "");
+            let localDefinitions = [];
+            if (record.path && memberNames.some(callsites_1.isBuiltinCallee)) {
+                const localRows = yield table
+                    .query()
+                    .select(["defined_symbols"])
+                    .where(this.scopeWhere(`path = '${(0, filter_builder_1.escapeSqlString)(String(record.path))}'`))
+                    .toArray();
+                localDefinitions = localRows.flatMap((row) => (0, arrow_1.toArr)(row.defined_symbols));
+            }
+            return (0, arrow_1.toArr)(record.referenced_symbols).filter((name) => {
+                if (!(0, callsites_1.isBuiltinCallee)(name) ||
+                    !memberNames.includes(name) ||
+                    localDefinitions.includes(name))
+                    return true;
+                const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                return new RegExp(`(?<![\\w.$])${escapedName}\\s*\\(`).test(content);
+            });
         });
     }
     /**
@@ -138,7 +163,8 @@ class GraphBuilder {
      */
     buildGraph(symbol) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
+            var _c, _d;
             const table = yield this.db.ensureTable();
             const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
             // 1. Get Center (Definition)
@@ -149,6 +175,8 @@ class GraphBuilder {
                 "start_line",
                 "defined_symbols",
                 "referenced_symbols",
+                "member_referenced_symbols",
+                "content",
                 "role",
                 "parent_symbol",
                 "complexity",
@@ -187,6 +215,26 @@ class GraphBuilder {
                 ])
                     .limit(25)
                     .toArray();
+                const memberNames = (0, arrow_1.toArr)((_a = centerRows[0]) === null || _a === void 0 ? void 0 : _a.member_referenced_symbols);
+                const content = String((_c = (_b = centerRows[0]) === null || _b === void 0 ? void 0 : _b.content) !== null && _c !== void 0 ? _c : "");
+                const bareCall = new RegExp(`(?<![\\w.$])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\(`).test(content);
+                const selfDefinition = rows.find((r) => { var _a; return String((_a = r.path) !== null && _a !== void 0 ? _a : "") === centerFile; });
+                if ((0, callsites_1.isBuiltinCallee)(name) &&
+                    memberNames.includes(name) &&
+                    !bareCall &&
+                    !selfDefinition) {
+                    calleeNodes.push({
+                        symbol: name,
+                        file: "",
+                        line: 0,
+                        role: "",
+                        calls: [],
+                        calledBy: [],
+                        resolution: "ambiguous-member",
+                        confidence: "INFERRED",
+                    });
+                    continue;
+                }
                 if (rows.length > 0) {
                     // Prefer-self-file, then same-language-family. Only fall back to the
                     // first row when no candidate shares the center's file or family.
@@ -195,7 +243,7 @@ class GraphBuilder {
                         ? rows.find((r) => { var _a; return (0, languages_1.languageFamilyForPath)(String((_a = r.path) !== null && _a !== void 0 ? _a : "")) ===
                             centerFamily; })
                         : undefined;
-                    calleeNodes.push(this.mapRowToNode(((_a = selfRow !== null && selfRow !== void 0 ? selfRow : familyRow) !== null && _a !== void 0 ? _a : rows[0]), name, "center"));
+                    calleeNodes.push(this.mapRowToNode(((_d = selfRow !== null && selfRow !== void 0 ? selfRow : familyRow) !== null && _d !== void 0 ? _d : rows[0]), name, "center"));
                 }
                 else if (!(0, callsites_1.isBuiltinCallee)(name)) {
                     // Unresolved + a known builtin (.map/.get/forEach) → suppress the

package/dist/lib/graph/impact-rollup.js

@@ -151,7 +151,7 @@ function formatImpactRollupHuman(rollup, opts) {
         }
         else {
             for (const test of rollup.topTests) {
-                lines.push(`  ${relativeToProject(opts.projectRoot, test.file)}:${test.line + 1}  (${(0, test_hits_1.hopLabelHuman)(test.hops)}${(0, test_hits_1.formatViaHuman)(test.via)})`);
+                lines.push(`  ${relativeToProject(opts.projectRoot, test.file)}:${test.line + 1}  (${(0, test_hits_1.hopLabelHuman)(test.hops, test.evidence)}${(0, test_hits_1.formatViaHuman)(test.via)})`);
             }
         }
     }
@@ -191,7 +191,7 @@ function formatImpactRollupAgent(rollup, opts) {
             lines.push([
                 "test",
                 `${relativeToProject(opts.projectRoot, test.file)}:${test.line + 1}`,
-                (0, test_hits_1.hopLabelAgent)(test.hops),
+                (0, test_hits_1.hopLabelAgent)(test.hops, test.evidence),
                 (0, test_hits_1.formatViaAgent)(test.via).trim(),
             ]
                 .filter(Boolean)

package/dist/lib/graph/impact.js

@@ -157,10 +157,20 @@ function findTests(symbols_1, vectorDb_1, projectRoot_1) {
         const expanded = yield expandFileSymbols(symbols, vectorDb, projectRoot, excludePrefixes);
         const families = yield resolveSymbolFamilies(expanded, vectorDb, projectRoot, excludePrefixes, symbolFamilies);
         for (const symbol of expanded) {
-            yield walkCallers(symbol, graphBuilder, testHits, 0, depth, new Set(), (_a = families.get(symbol)) !== null && _a !== void 0 ? _a : null);
+            const candidates = new Map();
+            yield walkCallers(symbol, graphBuilder, candidates, 0, depth, new Set(), (_a = families.get(symbol)) !== null && _a !== void 0 ? _a : null);
+            for (const [key, hit] of candidates) {
+                if (!symbols.includes(symbol))
+                    hit.evidence = "file-candidate";
+                const previous = testHits.get(key);
+                if (!previous ||
+                    (previous.evidence && !hit.evidence) ||
+                    (previous.evidence === hit.evidence && hit.hops < previous.hops))
+                    testHits.set(key, hit);
+            }
         }
-        if (testHits.size === 0) {
-            const importFiles = yield findImportFallbackTests(expanded, symbols, vectorDb, projectRoot, excludePrefixes, families);
+        if (![...testHits.values()].some((hit) => !hit.evidence)) {
+            const importFiles = yield findImportFallbackTests(symbols, vectorDb, projectRoot, excludePrefixes, families);
             for (const file of importFiles) {
                 testHits.set(`${file}:(referenced)`, {
                     file,
@@ -170,17 +180,19 @@ function findTests(symbols_1, vectorDb_1, projectRoot_1) {
                 });
             }
         }
-        return [...testHits.values()].sort((a, b) => a.hops - b.hops || a.file.localeCompare(b.file));
+        return [...testHits.values()].sort((a, b) => Number(!!a.evidence) - Number(!!b.evidence) ||
+            a.hops - b.hops ||
+            a.file.localeCompare(b.file));
     });
 }
-function findImportFallbackTests(expandedSymbols, originalSymbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies) {
+function findImportFallbackTests(originalSymbols, vectorDb, projectRoot, excludePrefixes, symbolFamilies) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const files = new Set();
         // Signal 1: referenced_symbols match (precise; works when the chunker
-        // captured call references in test bodies). Uses the expanded set so tests
-        // that call a method of the target class still match.
-        const dependents = yield findDependents(expandedSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes, symbolFamilies);
+        // captured call references in test bodies). Co-defined symbols are already
+        // exposed as file candidates and must not become target coverage here.
+        const dependents = yield findDependents(originalSymbols, vectorDb, projectRoot, undefined, 50, excludePrefixes, symbolFamilies);
         for (const d of dependents) {
             if (isTestPath(d.file))
                 files.add(d.file);

package/dist/lib/graph/test-hits.js

@@ -9,20 +9,22 @@ function groupTestHitsByFile(hits) {
     const byFile = new Map();
     // Sort by hops so the first hit per file carries the best line/hops and
     // `via` lists closest callers first ((referenced) fallback hits sort last).
-    const ordered = [...hits].sort((a, b) => (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
-        (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops));
+    const ordered = [...hits].sort((a, b) => Number(!!a.evidence) - Number(!!b.evidence) ||
+        (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
+            (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops));
     for (const h of ordered) {
         let g = byFile.get(h.file);
         if (!g) {
-            g = { file: h.file, line: h.line, hops: h.hops, via: [] };
+            g = Object.assign({ file: h.file, line: h.line, hops: h.hops, via: [] }, (h.evidence ? { evidence: h.evidence } : {}));
             byFile.set(h.file, g);
         }
         if (h.symbol && h.symbol !== "(referenced)" && !g.via.includes(h.symbol)) {
             g.via.push(h.symbol);
         }
     }
-    return [...byFile.values()].sort((a, b) => (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
-        (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops) ||
+    return [...byFile.values()].sort((a, b) => Number(!!a.evidence) - Number(!!b.evidence) ||
+        (a.hops === -1 ? Number.MAX_SAFE_INTEGER : a.hops) -
+            (b.hops === -1 ? Number.MAX_SAFE_INTEGER : b.hops) ||
         a.file.localeCompare(b.file));
 }
 const MAX_VIA = 3;
@@ -42,10 +44,14 @@ function formatViaHuman(via) {
     const more = via.length > MAX_VIA ? ` (+${via.length - MAX_VIA} more)` : "";
     return `, via ${shown}${more}`;
 }
-function hopLabelAgent(hops) {
+function hopLabelAgent(hops, evidence) {
+    if (evidence)
+        return "file-candidate";
     return hops === -1 ? "via-import" : hops === 0 ? "direct" : `${hops}-hop`;
 }
-function hopLabelHuman(hops) {
+function hopLabelHuman(hops, evidence) {
+    if (evidence)
+        return "same-file candidate";
     return hops === -1
         ? "via import"
         : hops === 0

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

@@ -43,12 +43,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectBatchProcessor = void 0;
+exports.applyReusedEmbeddings = applyReusedEmbeddings;
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
 const vector_db_1 = require("../store/vector-db");
 const cache_check_1 = require("../utils/cache-check");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
+const embedding_error_1 = require("../workers/embedding-error");
 const pool_1 = require("../workers/pool");
 const cache_coherence_1 = require("./cache-coherence");
 const file_policy_1 = require("./file-policy");
@@ -80,6 +82,8 @@ class ProjectBatchProcessor {
         this.closed = false;
         this.currentBatchAc = null;
         this.lastCorruptionLogMs = 0;
+        this.backendFailures = 0;
+        this.backendRetryAt = 0;
         this.policyChangedDuringBatch = false;
         /** Rolling window of recent batch outcomes — see `progress`. */
         this.recentBatches = [];
@@ -172,6 +176,18 @@ class ProjectBatchProcessor {
             recentReindexed,
         };
     }
+    loadReusableEmbeddings(absPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // An optimisation only: a failed lookup costs a full re-embed, nothing more.
+            try {
+                return yield this.vectorDb.getReusableEmbeddings(absPath);
+            }
+            catch (err) {
+                (0, logger_1.debug)(this.wtag, `embedding reuse lookup failed for ${absPath}: ${err instanceof Error ? err.message : String(err)}`);
+                return undefined;
+            }
+        });
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -188,8 +204,11 @@ class ProjectBatchProcessor {
         });
     }
     scheduleBatch(delayMs = DEBOUNCE_MS) {
+        delayMs = Math.max(delayMs, this.backendRetryAt - Date.now());
         const dueMs = Date.now() + Math.max(0, delayMs);
-        if (this.debounceTimer && this.debounceDueMs <= dueMs)
+        if (this.debounceTimer &&
+            this.debounceDueMs <= dueMs &&
+            this.debounceDueMs >= this.backendRetryAt)
             return;
         if (this.debounceTimer)
             clearTimeout(this.debounceTimer);
@@ -221,7 +240,10 @@ class ProjectBatchProcessor {
         const run = (this.runOperation
             ? this.runOperation(execute)
             : execute(new AbortController().signal)).catch((err) => {
-            console.error(`[${this.wtag}] Batch processing failed:`, err);
+            if ((err === null || err === void 0 ? void 0 : err.name) === "AbortError")
+                (0, logger_1.log)(this.wtag, "Batch cancelled during shutdown");
+            else
+                console.error(`[${this.wtag}] Batch processing failed:`, err);
         });
         this.activeBatch = run;
         void run.finally(() => {
@@ -290,6 +312,7 @@ class ProjectBatchProcessor {
                 const metaDeletes = [];
                 const completed = new Set();
                 const retryFailures = new Set();
+                let backendUnavailable = false;
                 const requeuePath = (absPath, event, failed) => {
                     var _a;
                     var _b;
@@ -360,11 +383,14 @@ class ProjectBatchProcessor {
                                 return;
                             }
                         }
-                        const result = yield pool.processFile({
-                            path: absPath,
-                            absolutePath: absPath,
-                            projectRoot: this.projectRoot,
-                        }, batchAc.signal);
+                        // A forced reprocess is a repair; it must not trust what is stored.
+                        const reusable = !forceReprocess && (cached === null || cached === void 0 ? void 0 : cached.hasVectors) !== false && (cached === null || cached === void 0 ? void 0 : cached.hash)
+                            ? yield this.loadReusableEmbeddings(absPath)
+                            : undefined;
+                        const result = yield pool.processFile(Object.assign({ path: absPath, absolutePath: absPath, projectRoot: this.projectRoot }, ((reusable === null || reusable === void 0 ? void 0 : reusable.size)
+                            ? { reusableKeys: Array.from(reusable.keys()) }
+                            : {})), batchAc.signal);
+                        applyReusedEmbeddings(result, reusable);
                         // Policy and filesystem state can change while embedding is in
                         // flight. Never commit a result that no longer describes the path.
                         const current = yield this.filePolicy.classifyFile(absPath);
@@ -418,6 +444,11 @@ class ProjectBatchProcessor {
                         if (batchAc.signal.aborted)
                             return;
                         const code = err === null || err === void 0 ? void 0 : err.code;
+                        if ((0, embedding_error_1.isEmbeddingBackendUnavailable)(err)) {
+                            backendUnavailable = true;
+                            stopDispatch = true;
+                            return;
+                        }
                         if (code === "ENOENT") {
                             deletes.push(absPath);
                             metaDeletes.push(absPath);
@@ -463,6 +494,16 @@ class ProjectBatchProcessor {
                     yield schedule(() => processOne(absPath, event));
                 }
                 yield Promise.allSettled(activeTasks);
+                if (backendUnavailable) {
+                    this.backendFailures++;
+                    const backoffMs = Math.min(60000, 5000 * Math.pow(2, Math.min(this.backendFailures - 1, 4)));
+                    this.backendRetryAt = Date.now() + backoffMs;
+                    (0, logger_1.log)(this.wtag, `Embedding backend unavailable — preserving file retry budgets; retry in ${backoffMs / 1000}s`);
+                }
+                else {
+                    this.backendFailures = 0;
+                    this.backendRetryAt = 0;
+                }
                 const pureDeleteCandidates = new Set(metaDeletes);
                 const authoritativeMetaDeletes = new Set();
                 for (const absPath of pureDeleteCandidates) {
@@ -652,3 +693,25 @@ class ProjectBatchProcessor {
 }
 exports.ProjectBatchProcessor = ProjectBatchProcessor;
 ProjectBatchProcessor.RECENT_BATCH_WINDOW = 5;
+/**
+ * Fill the records a worker left unembedded from the embeddings offered to it.
+ * Throws when one cannot be filled, so the file is retried rather than stored
+ * with an empty vector.
+ */
+function applyReusedEmbeddings(result, reusable) {
+    var _a;
+    if (!((_a = result.reused) === null || _a === void 0 ? void 0 : _a.length))
+        return;
+    for (const { index, key } of result.reused) {
+        const record = result.vectors[index];
+        const embedding = reusable === null || reusable === void 0 ? void 0 : reusable.get(key);
+        if (!record || !embedding) {
+            throw new Error(`worker reused an embedding that was not offered (chunk ${index})`);
+        }
+        record.vector = embedding.vector;
+        record.colbert = embedding.colbert;
+        record.colbert_scale = embedding.colbert_scale;
+        record.pooled_colbert_48d = embedding.pooled_colbert_48d;
+        record.doc_token_ids = embedding.doc_token_ids;
+    }
+}

package/dist/lib/index/embedding-reuse.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embeddingReuseKey = embeddingReuseKey;
+exports.toFloat32 = toFloat32;
+exports.toInt32 = toInt32;
+exports.toBytes = toBytes;
+const node_crypto_1 = require("node:crypto");
+/** Keyed by the exact text passed to the embedder (`PreparedChunk.content`). */
+function embeddingReuseKey(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function unwrap(val) {
+    if (val &&
+        !ArrayBuffer.isView(val) &&
+        typeof val.toArray === "function") {
+        return val.toArray();
+    }
+    return val;
+}
+// Copies rather than views: an Arrow view pins its whole record batch buffer.
+function toFloat32(val) {
+    const v = unwrap(val);
+    if (v instanceof Float32Array)
+        return v.slice();
+    if (ArrayBuffer.isView(v) || Array.isArray(v)) {
+        return Float32Array.from(v);
+    }
+    return new Float32Array(0);
+}
+function toInt32(val) {
+    const v = unwrap(val);
+    if (v instanceof Int32Array)
+        return v.slice();
+    if (ArrayBuffer.isView(v) || Array.isArray(v)) {
+        return Int32Array.from(v);
+    }
+    return new Int32Array(0);
+}
+function toBytes(val) {
+    const v = unwrap(val);
+    if (ArrayBuffer.isView(v)) {
+        return Buffer.from(new Uint8Array(v.buffer, v.byteOffset, v.byteLength).slice());
+    }
+    if (Array.isArray(v))
+        return Buffer.from(v);
+    return Buffer.alloc(0);
+}

package/dist/lib/index/grammar-loader.js

@@ -56,15 +56,24 @@ for (const lang of languages_1.LANGUAGES) {
     }
 }
 const downloadFile = (url, dest) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield fetch(url, {
-        headers: {
-            "User-Agent": "gmax",
-        },
-    });
-    if (!response.ok)
-        throw new Error(`Failed to download ${url}`);
-    const arrayBuffer = yield response.arrayBuffer();
-    fs.writeFileSync(dest, Buffer.from(arrayBuffer));
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            const response = yield fetch(url, {
+                headers: { "User-Agent": "gmax" },
+                signal: AbortSignal.timeout(30000),
+            });
+            if (!response.ok)
+                throw new Error(`Failed to download ${url}: HTTP ${response.status}`);
+            const arrayBuffer = yield response.arrayBuffer();
+            fs.writeFileSync(dest, Buffer.from(arrayBuffer));
+            return;
+        }
+        catch (error) {
+            if (attempt === 3)
+                throw error;
+            yield new Promise((resolve) => setTimeout(resolve, attempt * 500));
+        }
+    }
 });
 function ensureGrammars() {
     return __awaiter(this, arguments, void 0, function* (log = console.log, options) {
@@ -73,6 +82,7 @@ function ensureGrammars() {
             fs.mkdirSync(exports.GRAMMARS_DIR, { recursive: true });
         }
         const silent = (_a = options === null || options === void 0 ? void 0 : options.silent) !== null && _a !== void 0 ? _a : false;
+        const failed = [];
         for (const [lang, url] of Object.entries(GRAMMAR_URLS)) {
             const dest = path.join(exports.GRAMMARS_DIR, `tree-sitter-${lang}.wasm`);
             if (fs.existsSync(dest)) {
@@ -99,6 +109,7 @@ function ensureGrammars() {
                     }
                 }
                 catch (err) {
+                    failed.push(lang);
                     if (log === console.log) {
                         console.log("Failed");
                     }
@@ -106,5 +117,7 @@ function ensureGrammars() {
                 }
             }
         }
+        if ((options === null || options === void 0 ? void 0 : options.strict) && failed.length)
+            throw new Error(`Required grammars could not be downloaded: ${failed.join(", ")}`);
     });
 }

package/dist/lib/output/formatter.js

@@ -191,7 +191,7 @@ function formatTrace(graph, options) {
                 lines.push(`  ${style.cyan("↓")} ${style.green(callee.symbol)} ${style.dim(`(${callee.file}:${callee.line})`)}`);
             }
             else {
-                lines.push(`  ${style.cyan("↓")} ${callee.symbol} ${style.dim("(not indexed)")}`);
+                lines.push(`  ${style.cyan("↓")} ${callee.symbol} ${style.dim(callee.resolution === "ambiguous-member" ? "(receiver unresolved)" : "(not indexed)")}`);
             }
         });
     }