@vibgrate/cli 2026.818.1 → 2026.818.2

package/dist/{chunk-MHJBIGWV.js → chunk-VQ5KMHW6.js}

@@ -3,13 +3,13 @@ import { isRelevantChange } from './chunk-DBX3DL27.js';
 import { isSkippedDirName, SKIP_FILES } from './chunk-POOL355F.js';
 import { inventory } from './chunk-6BEBJCK4.js';
 import { resolveOne } from './chunk-J7LKEB2R.js';
-import { impactOf, queryGraph, queryGraphSemantic } from './chunk-DUCEKH7Q.js';
-import { loadGraph } from './chunk-SBHK4ECM.js';
+import { impactOf, queryGraph, queryGraphSemantic } from './chunk-MRZHNUN7.js';
+import { loadGraph } from './chunk-KU7FI5EV.js';
 import { vgdSocketPath, vgdPidPath } from './chunk-NDNNOAS6.js';
-import { embedTargets, readCachedVectors, cosine } from './chunk-WVTGF2MP.js';
+import { embedTargets, readCachedVectors, cosine } from './chunk-2C33WR5O.js';
 import { cacheDir } from './chunk-MVPRPSXU.js';
 import { stableStringify } from './chunk-O3LABX6I.js';
-import { VERSION } from './chunk-SUD54UGN.js';
+import { VERSION } from './chunk-4NTNMT6T.js';
 import { repositoryIdFromRoot, globalGraphPathForRef, globalGraphPath } from './chunk-BWPBB45M.js';
 import { hashString, canonicalize, hashBytes } from './chunk-JFGYT6BI.js';
 import { activeGraphSlotKey, detectGitRef, clearDetectGitRefCache } from './chunk-BPF3YX2U.js';
@@ -85,7 +85,8 @@ function parseRequest(line) {
     return {
       op: "embed-index",
       repositoryId: repositoryId.trim(),
-      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0,
+      wait: raw.wait === false ? false : void 0
     };
   }
   if (op === "embed-rank") {
@@ -649,8 +650,10 @@ var EmbedBroker = class {
   buffer = "";
   pending = /* @__PURE__ */ new Map();
   indexes = /* @__PURE__ */ new Map();
-  /** Slot keys with a build in flight, so warms are not duplicated. */
-  building = /* @__PURE__ */ new Set();
+  /** In-flight builds, so a second caller waits for the same work instead of seeing an empty slot. */
+  inflight = /* @__PURE__ */ new Map();
+  /** One deferred retry per slot after standing down for an on-disk writer. */
+  rewarmTimers = /* @__PURE__ */ new Map();
   /** The slot most recently made current — logged on change. */
   currentKey;
   graphProvider;
@@ -661,6 +664,7 @@ var EmbedBroker = class {
   requestTimeoutMs;
   batchSize;
   now;
+  sleepImpl;
   constructor(options = {}) {
     this.log = options.log ?? (() => {
     });
@@ -669,6 +673,7 @@ var EmbedBroker = class {
     this.requestTimeoutMs = options.requestTimeoutMs ?? 12e4;
     this.batchSize = options.batchSize ?? 256;
     this.now = options.now ?? (() => Date.now());
+    this.sleepImpl = options.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
   }
   status() {
     return {
@@ -715,14 +720,15 @@ var EmbedBroker = class {
     const key = activeGraphSlotKey(repositoryId, gitRef);
     const existing = this.indexes.get(key);
     const nodeCount = graph.nodes?.length ?? 0;
-    if (existing && existing.state === "ready") {
-      this.log(`semantic: ${repositoryId}@${gitRef} graph republished \u2014 index stale (${existing.vectors.size} vectors dropped)`);
+    const kept = existing?.vectors.size ? new Map(existing.vectors) : /* @__PURE__ */ new Map();
+    if (existing && existing.vectors.size > 0) {
+      this.log(`semantic: ${repositoryId}@${gitRef} graph republished \u2014 index stale (${existing.vectors.size} vectors kept until rebuild)`);
     }
     this.indexes.set(key, {
       repositoryId,
       gitRef,
       state: "stale",
-      vectors: /* @__PURE__ */ new Map(),
+      vectors: kept,
       nodeCount
     });
   }
@@ -758,7 +764,7 @@ var EmbedBroker = class {
     }
     if (this.gaveUp) return;
     const idx = this.indexes.get(key);
-    if (idx?.state === "ready" || this.building.has(key)) return;
+    if (idx?.state === "ready" || this.inflight.has(key)) return;
     const graph = this.graphProvider?.(repositoryId, gitRef);
     if (!graph) return;
     void this.ensureIndex(repositoryId, gitRef, graph);
@@ -769,18 +775,26 @@ var EmbedBroker = class {
     const idx = this.indexes.get(key);
     if (!idx) return;
     this.indexes.delete(key);
+    this.clearRewarm(key);
     this.log(`semantic: ${repositoryId}@${gitRef} index evicted with its graph slot (${idx.vectors.size} vectors freed)`);
   }
   /** Drop everything (daemon shutdown / registry clear). */
   clear() {
     this.indexes.clear();
-    this.building.clear();
+    this.inflight.clear();
+    for (const timer of this.rewarmTimers.values()) clearTimeout(timer);
+    this.rewarmTimers.clear();
   }
   /**
    * Ensure the slot has vectors, building them if needed. Resolves when the
    * index is ready or has definitively failed; never throws.
+   *
+   * A second caller for the same slot waits for the in-flight build instead of
+   * returning the empty placeholder — that empty return is what made `vg ask`
+   * re-embed tens of thousands of nodes in-process while vgd was already doing
+   * the same work.
    */
-  async ensureIndex(repositoryId, gitRef, graph) {
+  async ensureIndex(repositoryId, gitRef, graph, options) {
     const key = activeGraphSlotKey(repositoryId, gitRef);
     let idx = this.indexes.get(key);
     if (!idx) {
@@ -793,11 +807,23 @@ var EmbedBroker = class {
       idx.error = this.reason ?? "embedding worker unavailable";
       return idx;
     }
-    if (this.building.has(key)) return idx;
-    this.building.add(key);
+    const pending = this.inflight.get(key);
+    if (pending) return pending;
+    const work = this.buildIndex(key, idx, repositoryId, gitRef, graph, options).finally(() => {
+      if (this.inflight.get(key) === work) this.inflight.delete(key);
+    });
+    this.inflight.set(key, work);
+    return work;
+  }
+  async buildIndex(key, idx, repositoryId, gitRef, graph, options) {
     idx.state = "building";
     const started = this.now();
-    const seeded = this.seedFromDisk(repositoryId, graph);
+    let seeded = this.seedFromDisk(repositoryId, graph);
+    if (seeded?.writerBusy && seeded.pending.length && options?.waitForWriter) {
+      this.log(`semantic: ${repositoryId}@${gitRef} waiting for another process to finish the on-disk index\u2026`);
+      await this.waitWhileWriterBusy(repositoryId, graph, options.waitForWriterMs ?? 3e5);
+      seeded = this.seedFromDisk(repositoryId, graph);
+    }
     const targets = seeded?.pending ?? embedTargets(graph);
     const vectors = seeded ? seeded.vectors : /* @__PURE__ */ new Map();
     const nodeCount = seeded ? seeded.vectors.size + seeded.pending.length : targets.length;
@@ -811,10 +837,10 @@ var EmbedBroker = class {
       idx.vectors = vectors;
       idx.pending = targets.length;
       idx.state = vectors.size ? "stale" : "absent";
-      this.building.delete(key);
       this.log(
         `semantic: ${repositoryId}@${gitRef} left at ${targets.length} pending \u2014 another process is writing the on-disk index; re-warming when it reports in`
       );
+      this.scheduleRewarm(repositoryId, gitRef);
       return idx;
     }
     this.log(`semantic: building index for ${repositoryId}@${gitRef} (${targets.length} of ${nodeCount} nodes)\u2026`);
@@ -826,9 +852,16 @@ var EmbedBroker = class {
           const v = out[j];
           if (v) vectors.set(t.id, v);
         });
+        if (idx.vectors.size === 0 || idx.vectors === vectors) idx.vectors = vectors;
+        idx.pending = Math.max(0, nodeCount - vectors.size);
         const live = this.indexes.get(key);
         if (!live || live !== idx) {
           this.log(`semantic: index build for ${repositoryId}@${gitRef} abandoned \u2014 slot changed underneath it`);
+          this.inflight.delete(key);
+          if (live && live !== idx) {
+            const nextGraph = this.graphProvider?.(repositoryId, gitRef) ?? graph;
+            return this.ensureIndex(repositoryId, gitRef, nextGraph, options);
+          }
           return idx;
         }
       }
@@ -838,6 +871,7 @@ var EmbedBroker = class {
       idx.builtAt = this.now();
       idx.buildMs = idx.builtAt - started;
       idx.error = void 0;
+      this.clearRewarm(key);
       this.log(`semantic: index ready for ${repositoryId}@${gitRef} \u2014 ${vectors.size} vectors in ${idx.buildMs}ms`);
     } catch (err) {
       idx.vectors = vectors;
@@ -845,11 +879,39 @@ var EmbedBroker = class {
       idx.state = "failed";
       idx.error = err instanceof Error ? err.message : String(err);
       this.log(`semantic: index build failed for ${repositoryId}@${gitRef} \u2014 ${idx.error}; callers fall back to lexical`);
-    } finally {
-      this.building.delete(key);
     }
     return idx;
   }
+  /** Poll the on-disk lock until the writer is gone or `timeoutMs` elapses. */
+  async waitWhileWriterBusy(repositoryId, graph, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const read = this.seedFromDisk(repositoryId, graph);
+      if (!read?.writerBusy) return;
+      await this.sleepImpl(250);
+    }
+  }
+  /** Retry a slot that stood down for an on-disk writer, once the writer should have moved. */
+  scheduleRewarm(repositoryId, gitRef) {
+    const key = activeGraphSlotKey(repositoryId, gitRef);
+    if (this.rewarmTimers.has(key)) return;
+    const timer = setTimeout(() => {
+      this.rewarmTimers.delete(key);
+      const idx = this.indexes.get(key);
+      if (!idx || idx.state === "ready" || this.inflight.has(key)) return;
+      const graph = this.graphProvider?.(repositoryId, gitRef);
+      if (!graph) return;
+      void this.ensureIndex(repositoryId, gitRef, graph);
+    }, 2e3);
+    timer.unref?.();
+    this.rewarmTimers.set(key, timer);
+  }
+  clearRewarm(key) {
+    const timer = this.rewarmTimers.get(key);
+    if (!timer) return;
+    clearTimeout(timer);
+    this.rewarmTimers.delete(key);
+  }
   /**
    * Read this slot's vectors out of the repo's on-disk cache. Needs the repo
    * root from the registry; a repository the daemon has no root for (a
@@ -908,6 +970,8 @@ var EmbedBroker = class {
   }
   /** Stop the worker (daemon shutdown). Safe to call when already stopped. */
   stop() {
+    for (const timer of this.rewarmTimers.values()) clearTimeout(timer);
+    this.rewarmTimers.clear();
     const child = this.child;
     this.child = null;
     this.starting = false;
@@ -1666,7 +1730,20 @@ async function handleLine(line, ctx) {
       if (!slot) {
         return { ok: false, error: `no graph slot for ${req.repositoryId}@${gitRef} \u2014 publish the map first`, code: "no_slot" };
       }
-      const idx = await ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph);
+      if (req.wait === false) {
+        void ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph, { waitForWriter: true });
+        const kicked = ctx.embedBroker.slot(req.repositoryId, gitRef);
+        return {
+          ok: true,
+          indexed: true,
+          repositoryId: req.repositoryId,
+          gitRef,
+          state: kicked?.state ?? "building",
+          vectors: kicked?.vectors.size ?? 0,
+          buildMs: kicked?.buildMs
+        };
+      }
+      const idx = await ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph, { waitForWriter: true });
       return {
         ok: true,
         indexed: true,
@@ -1684,7 +1761,24 @@ async function handleLine(line, ctx) {
       if (!slot) {
         return { ok: false, error: `no graph slot for ${req.repositoryId}@${gitRef} \u2014 publish the map first`, code: "no_slot" };
       }
-      await ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph);
+      const existing = ctx.embedBroker.slot(req.repositoryId, gitRef);
+      if (existing && existing.vectors.size > 0) {
+        if (existing.state !== "ready") {
+          void ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph);
+        }
+      } else {
+        void ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph, { waitForWriter: true });
+        const warming = ctx.embedBroker.slot(req.repositoryId, gitRef);
+        return {
+          ok: false,
+          error: "semantic index is warming \u2014 retry shortly",
+          code: "semantic_warming",
+          state: warming?.state ?? "building",
+          vectors: warming?.vectors.size ?? 0,
+          pending: warming?.pending,
+          nodeCount: warming?.nodeCount
+        };
+      }
       const started = Date.now();
       const result = await ctx.embedBroker.rank(req.repositoryId, gitRef, req.text, req.limit);
       if (!result) {
@@ -2017,5 +2111,5 @@ var BranchGraphSession = class {
 };
 
 export { ActiveGraphCache, BranchGraphSession, DEFAULT_ACTIVE_GRAPH_IDLE_MS, VGD_PROTOCOL_VERSION, WorkspaceRegistry, endOfLine, findPackageLine, findRuntimeLine, isDependencyFile, isManifest, loadScanCache, manifestHash, manifestKind, parseRequest, startVgdServer, writeScanCache };
-//# sourceMappingURL=chunk-MHJBIGWV.js.map
-//# sourceMappingURL=chunk-MHJBIGWV.js.map
+//# sourceMappingURL=chunk-VQ5KMHW6.js.map
+//# sourceMappingURL=chunk-VQ5KMHW6.js.map