@vibgrate/cli 2026.817.2 → 2026.818.2

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

@@ -1,13 +1,20 @@
 import { listHostSessions, hostSessionPoolSize, acquireHostSession, evictIdleSessions, clearHostSessionPool, dropHostSession, generateOnSession } from './chunk-3LOWJSAF.js';
-import { vgdSocketPath, vgdPidPath } from './chunk-RBIRXQR6.js';
+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 } from './chunk-Q4G2BWE3.js';
-import { loadGraph } from './chunk-3FMRFECC.js';
-import { VERSION } from './chunk-PRG2ULPK.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-2C33WR5O.js';
+import { cacheDir } from './chunk-MVPRPSXU.js';
+import { stableStringify } from './chunk-O3LABX6I.js';
+import { VERSION } from './chunk-4NTNMT6T.js';
 import { repositoryIdFromRoot, globalGraphPathForRef, globalGraphPath } from './chunk-BWPBB45M.js';
-import { activeGraphSlotKey, detectGitRef } from './chunk-BPF3YX2U.js';
-import * as path from 'path';
-import * as fs2 from 'fs';
+import { hashString, canonicalize, hashBytes } from './chunk-JFGYT6BI.js';
+import { activeGraphSlotKey, detectGitRef, clearDetectGitRefCache } from './chunk-BPF3YX2U.js';
+import * as path3 from 'path';
+import * as fs4 from 'fs';
 import * as net from 'net';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
@@ -78,9 +85,41 @@ 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") {
+    const repositoryId = raw.repositoryId;
+    const gitRef = raw.gitRef;
+    const text = raw.text;
+    const limit = raw.limit;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "embed-rank requires repositoryId" };
+    if (typeof text !== "string" || !text.trim()) return { error: "embed-rank requires text" };
+    return {
+      op: "embed-rank",
+      repositoryId: repositoryId.trim(),
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0,
+      // Same bound as embed-query: untrusted socket input, one worker.
+      text: text.trim().slice(0, 8e3),
+      // Only the ORDER of this list reaches the caller's rank fusion, and a
+      // candidate past a few hundred can never surface in a 12-row answer —
+      // so a generous cap costs nothing and a huge one buys nothing.
+      limit: typeof limit === "number" && limit > 0 ? Math.min(Math.floor(limit), 1e3) : void 0
+    };
+  }
+  if (op === "watch-slots") {
+    const repositoryId = raw.repositoryId;
+    return {
+      op: "watch-slots",
+      repositoryId: typeof repositoryId === "string" && repositoryId.trim() ? repositoryId.trim() : void 0
     };
   }
+  if (op === "dep-context") {
+    const repositoryId = raw.repositoryId;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "dep-context requires repositoryId" };
+    return { op: "dep-context", repositoryId: repositoryId.trim() };
+  }
   if (op === "query-graph") {
     const repositoryId = raw.repositoryId;
     const query = raw.query;
@@ -93,7 +132,13 @@ function parseRequest(line) {
       repositoryId: repositoryId.trim(),
       query: query.trim(),
       limit: typeof limit === "number" && limit > 0 ? Math.min(Math.floor(limit), 50) : void 0,
-      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0,
+      // Opt-in, and left off the parsed request entirely when not asked: a
+      // client that asks for semantic gets the fused ranking when the slot's
+      // index is ready, and the lexical answer when it is not. Ranking and
+      // fusion both happen here, so the caller needs neither the graph nor the
+      // embedder — which is the whole reason a panel can afford to ask.
+      semantic: raw.semantic === true ? true : void 0
     };
   }
   if (op === "impact-of") {
@@ -386,6 +431,8 @@ var WorkspaceRegistry = class {
    * index can never describe a ref its graph no longer holds.
    */
   slotListener;
+  /** Told after a graph is stored, so the daemon can push to subscribers. */
+  publishListener;
   /** Multi-branch in-memory graphs (shared across registered workspaces). */
   graphs = new ActiveGraphCache({
     onEvict: (slot) => this.slotListener?.onGraphEvict(slot.repositoryId, slot.gitRef)
@@ -394,8 +441,17 @@ var WorkspaceRegistry = class {
   setSlotListener(listener) {
     this.slotListener = listener;
   }
+  /**
+   * Attach the push channel. Separate from {@link GraphSlotListener} on
+   * purpose: that one keeps *slot-scoped resources* in step and must run
+   * before anyone can query, while this one notifies *other processes* and
+   * must run after the store is complete.
+   */
+  setPublishListener(listener) {
+    this.publishListener = listener;
+  }
   register(root, now = () => /* @__PURE__ */ new Date(), meta = {}) {
-    const resolved = path.resolve(root);
+    const resolved = path3.resolve(root);
     const id = repositoryIdFromRoot(resolved);
     const git = meta.gitRef ? { ref: meta.gitRef, kind: "branch" } : detectGitRef(resolved);
     const graphPath = git.kind !== "none" && git.ref ? globalGraphPathForRef(resolved, git.ref) : globalGraphPath(resolved);
@@ -409,7 +465,7 @@ var WorkspaceRegistry = class {
       gitRef: git.ref || void 0
     };
     this.byId.set(id, record);
-    if (git.ref) this.graphs.select(id, git.ref);
+    if (git.ref) this.selectGitRef(id, git.ref);
     return record;
   }
   /**
@@ -421,6 +477,7 @@ var WorkspaceRegistry = class {
     this.graphs.select(repositoryId, gitRef);
     this.slotListener?.onGraphPut(repositoryId, gitRef, graph);
     this.slotListener?.onGraphSelect(repositoryId, gitRef);
+    this.publishListener?.(repositoryId, gitRef, graph);
   }
   /** Switch the current branch slot for a repository (no load). */
   selectGitRef(repositoryId, gitRef) {
@@ -432,14 +489,14 @@ var WorkspaceRegistry = class {
     return members.map((m) => this.register(m.root, now, { label: m.label, role: m.role }));
   }
   unregister(root) {
-    const id = repositoryIdFromRoot(path.resolve(root));
+    const id = repositoryIdFromRoot(path3.resolve(root));
     return this.byId.delete(id);
   }
   list() {
     return [...this.byId.values()].sort((a, b) => a.root.localeCompare(b.root));
   }
   get(root) {
-    return this.byId.get(repositoryIdFromRoot(path.resolve(root)));
+    return this.byId.get(repositoryIdFromRoot(path3.resolve(root)));
   }
   /** Lookup by stable repository id. */
   getById(repositoryId) {
@@ -482,8 +539,8 @@ var VgdHostBroker = class {
   }
   status() {
     const leases = {};
-    for (const [path4, clients] of this.leases) {
-      leases[path4] = clients.size;
+    for (const [path6, clients] of this.leases) {
+      leases[path6] = clients.size;
     }
     return {
       poolSize: hostSessionPoolSize(),
@@ -582,10 +639,6 @@ function getVgdHostBroker() {
   if (!defaultBroker) defaultBroker = new VgdHostBroker();
   return defaultBroker;
 }
-function nodeText(node) {
-  const parts = [node.qualifiedName || node.name, node.kind, node.file, node.doc].filter((p) => typeof p === "string" && p.length > 0);
-  return parts.join(" \xB7 ").slice(0, 512);
-}
 var EmbedBroker = class {
   child = null;
   starting = false;
@@ -597,17 +650,21 @@ 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;
+  rootProvider;
   log;
   spawnWorker;
   maxCrashes;
   requestTimeoutMs;
   batchSize;
   now;
+  sleepImpl;
   constructor(options = {}) {
     this.log = options.log ?? (() => {
     });
@@ -616,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 {
@@ -637,6 +695,7 @@ var EmbedBroker = class {
         state: idx.state,
         vectors: idx.vectors.size,
         nodeCount: idx.nodeCount,
+        pending: idx.pending,
         builtAt: idx.builtAt,
         buildMs: idx.buildMs,
         error: idx.error
@@ -661,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
     });
   }
@@ -679,6 +739,15 @@ var EmbedBroker = class {
   setGraphProvider(provider) {
     this.graphProvider = provider;
   }
+  /**
+   * Supplies the absolute repository root for a slot, so the broker can read
+   * that repo's on-disk vector cache. It cannot come from the graph:
+   * `meta.root` is deliberately relative (`.`) so snapshots stay portable
+   * across machines. The registry holds the real path.
+   */
+  setRootProvider(provider) {
+    this.rootProvider = provider;
+  }
   /**
    * A slot became current — a branch switch, a new repo, a fresh publish.
    * The matching index is swapped in, and warmed in the background if it is
@@ -695,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);
@@ -706,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) {
@@ -730,43 +807,156 @@ 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 nodes = (graph.nodes ?? []).filter((n) => !!n?.id);
     const started = this.now();
-    this.log(`semantic: building index for ${repositoryId}@${gitRef} (${nodes.length} nodes)\u2026`);
+    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;
+    idx.nodeCount = nodeCount;
+    if (seeded && seeded.vectors.size) {
+      this.log(
+        `semantic: seeded ${repositoryId}@${gitRef} from the on-disk index \u2014 ${seeded.vectors.size} vectors, ${seeded.pending.length} pending`
+      );
+    }
+    if (seeded?.writerBusy && targets.length) {
+      idx.vectors = vectors;
+      idx.pending = targets.length;
+      idx.state = vectors.size ? "stale" : "absent";
+      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`);
     try {
-      const vectors = /* @__PURE__ */ new Map();
-      for (let i = 0; i < nodes.length; i += this.batchSize) {
-        const batch = nodes.slice(i, i + this.batchSize);
-        const out = await this.embed(batch.map((n) => nodeText(n)));
-        batch.forEach((n, j) => {
+      for (let i = 0; i < targets.length; i += this.batchSize) {
+        const batch = targets.slice(i, i + this.batchSize);
+        const out = await this.embed(batch.map((t) => t.text));
+        batch.forEach((t, j) => {
           const v = out[j];
-          if (v) vectors.set(n.id, v);
+          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;
         }
       }
       idx.vectors = vectors;
-      idx.nodeCount = nodes.length;
+      idx.pending = void 0;
       idx.state = "ready";
       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;
+      idx.pending = targets.length;
       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
+   * synthetic publish in a test) simply builds from scratch.
+   */
+  seedFromDisk(repositoryId, graph) {
+    const root = this.rootProvider?.(repositoryId);
+    if (!root) return null;
+    try {
+      const read = readCachedVectors(graph, root);
+      if (!this.model) this.model = read.model;
+      return { vectors: read.vectors, pending: read.pending, writerBusy: read.writerBusy };
+    } catch (err) {
+      this.log(`semantic: could not read the on-disk index \u2014 ${err instanceof Error ? err.message : String(err)}; embedding from scratch`);
+      return null;
+    }
+  }
+  /**
+   * Rank a slot's nodes against one question, inside the daemon.
+   *
+   * This is the op that makes the resident index worth holding. The
+   * alternative — shipping the vectors to the caller so it can rank locally —
+   * moves tens of megabytes over a socket per ask; ranking here moves one
+   * question in and a few hundred (id, score) pairs out.
+   *
+   * Only the *order* of this list reaches the caller's rank fusion, so
+   * truncating at `limit` is not an approximation of the answer: a candidate
+   * ranked past a few hundred cannot reach a 12-row result under RRF.
+   *
+   * Returns null whenever semantic is unavailable — a caller that gets null
+   * runs its own in-process pass, exactly as it does with no daemon at all.
+   */
+  async rank(repositoryId, gitRef, text, limit = 200) {
+    const idx = this.slot(repositoryId, gitRef);
+    if (!idx || idx.vectors.size === 0) return null;
+    const queryVec = await this.embedQuery(text);
+    if (!queryVec) return null;
+    const scored = [];
+    for (const [id, vec] of idx.vectors) {
+      const score = cosine(queryVec, vec);
+      if (score > 0) scored.push({ id, score });
+    }
+    scored.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+    return { ranked: scored.slice(0, limit), state: idx.state, vectors: idx.vectors.size };
+  }
   /** Embed one query string. Returns null when semantic is not available. */
   async embedQuery(text) {
     if (this.gaveUp) return null;
@@ -780,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;
@@ -880,13 +1072,13 @@ var EmbedBroker = class {
       return Promise.reject(error);
     }
     const id = this.nextId++;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`embedding request timed out after ${this.requestTimeoutMs}ms`));
       }, this.requestTimeoutMs);
       timer.unref?.();
-      this.pending.set(id, { resolve: resolve2, reject, timer });
+      this.pending.set(id, { resolve: resolve3, reject, timer });
       try {
         child.stdin?.write(JSON.stringify({ id, op: "embed", texts, query }) + "\n");
       } catch (err) {
@@ -902,9 +1094,9 @@ var EmbedBroker = class {
   }
 };
 function defaultSpawnWorker() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const entry = path.join(here, "embed-worker-main.js");
-  if (!fs2.existsSync(entry)) {
+  const here = path3.dirname(fileURLToPath(import.meta.url));
+  const entry = path3.join(here, "embed-worker-main.js");
+  if (!fs4.existsSync(entry)) {
     throw new Error(`embedding worker not found at ${entry} \u2014 semantic runs lexically`);
   }
   return spawn(process.execPath, [entry], {
@@ -915,6 +1107,446 @@ function defaultSpawnWorker() {
   });
 }
 
+// src/lsp/manifest-positions.ts
+function manifestKind(filePath) {
+  const base = (filePath.split(/[\\/]/).pop() ?? "").toLowerCase();
+  if (base === "package.json") return "package.json";
+  if (base === "go.mod") return "go.mod";
+  if (base === "requirements.txt" || /^requirements.*\.txt$/.test(base)) return "requirements.txt";
+  if (base === "pyproject.toml") return "pyproject.toml";
+  if (base === "cargo.toml") return "Cargo.toml";
+  if (base === "pom.xml") return "pom.xml";
+  if (base === "build.gradle" || base === "build.gradle.kts") return "build.gradle";
+  if (base === "gemfile") return "Gemfile";
+  if (base === "composer.json") return "composer.json";
+  if (base === "pubspec.yaml") return "pubspec.yaml";
+  if (base === "mix.exs") return "mix.exs";
+  if (base.endsWith(".csproj") || base.endsWith(".fsproj") || base.endsWith(".vbproj")) return "csproj";
+  if (base === "dockerfile" || base.startsWith("dockerfile.")) return "Dockerfile";
+  return "unknown";
+}
+function isManifest(filePath) {
+  return manifestKind(filePath) !== "unknown";
+}
+function esc(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findPackageLine(text, pkg, kind) {
+  const lines = text.split(/\r?\n/);
+  const p = esc(pkg);
+  const patterns = (() => {
+    switch (kind) {
+      case "package.json":
+      case "composer.json":
+        return [new RegExp(`^\\s*"${p}"\\s*:`)];
+      case "go.mod":
+        return [new RegExp(`^\\s*(?:require\\s+)?${p}\\s+v?\\d`)];
+      case "requirements.txt":
+        return [new RegExp(`^\\s*${p}\\s*(?:\\[[^\\]]*\\])?\\s*(?:[=<>!~]|$)`, "i")];
+      case "pyproject.toml":
+      case "Cargo.toml":
+        return [
+          new RegExp(`^\\s*${p}\\s*=`),
+          new RegExp(`^\\s*"${p}\\s*(?:[=<>!~\\[]|")`)
+        ];
+      case "pom.xml":
+        return [new RegExp(`<artifactId>\\s*${p}\\s*</artifactId>`)];
+      case "build.gradle":
+        return [new RegExp(`["']${p}(?:["':])`)];
+      case "Gemfile":
+        return [new RegExp(`^\\s*gem\\s+["']${p}["']`)];
+      case "pubspec.yaml":
+        return [new RegExp(`^\\s*${p}\\s*:`)];
+      case "mix.exs":
+        return [new RegExp(`\\{\\s*:${p}\\s*,`)];
+      case "csproj":
+        return [new RegExp(`Include\\s*=\\s*"${p}"`, "i")];
+      case "Dockerfile":
+        return [new RegExp(`^\\s*FROM\\s+.*${p}`, "i")];
+      default:
+        return [];
+    }
+  })();
+  for (const re of patterns) {
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) return i;
+    }
+  }
+  return -1;
+}
+function findRuntimeLine(text, kind) {
+  const lines = text.split(/\r?\n/);
+  const patterns = (() => {
+    switch (kind) {
+      case "package.json":
+        return [/^\s*"node"\s*:/, /^\s*"engines"\s*:/];
+      case "go.mod":
+        return [/^\s*go\s+\d/];
+      case "pyproject.toml":
+        return [/^\s*(?:requires-python|python)\s*=/];
+      case "pom.xml":
+        return [/<(?:java\.version|maven\.compiler\.(?:source|target|release))>/];
+      case "build.gradle":
+        return [/(?:sourceCompatibility|targetCompatibility|JavaVersion)/];
+      case "csproj":
+        return [/<TargetFrameworks?>/i];
+      case "Dockerfile":
+        return [/^\s*FROM\s+/i];
+      default:
+        return [];
+    }
+  })();
+  for (const re of patterns) {
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) return i;
+    }
+  }
+  return -1;
+}
+function endOfLine(text, line) {
+  const lines = text.split(/\r?\n/);
+  return (lines[line] ?? "").length;
+}
+
+// src/lsp/scan-cache.ts
+var CACHE_VERSION = "vg-lsp-scan-cache/2";
+function cachePath(root) {
+  return path3.join(cacheDir(root), "lsp-scan.json");
+}
+function manifestHash(root) {
+  const files = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (isSkippedDirName(entry.name)) continue;
+        walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const base = entry.name.toLowerCase();
+      if (!isManifest(abs) && !SKIP_FILES.has(base)) continue;
+      try {
+        const rel = path3.relative(root, abs).split(path3.sep).join("/");
+        files.push({ rel, hash: hashBytes(fs4.readFileSync(abs)) });
+      } catch {
+      }
+    }
+  };
+  walk(root);
+  files.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  return hashString(canonicalize(files));
+}
+function isDependencyFile(root, filePath) {
+  const rel = path3.relative(path3.resolve(root), path3.resolve(filePath));
+  if (rel === "" || rel.startsWith("..") || path3.isAbsolute(rel)) return false;
+  const parts = rel.split(path3.sep);
+  if (parts.slice(0, -1).some((dir) => isSkippedDirName(dir))) return false;
+  const base = parts[parts.length - 1].toLowerCase();
+  return isManifest(filePath) || SKIP_FILES.has(base);
+}
+function loadScanCache(root, key) {
+  try {
+    const raw = JSON.parse(fs4.readFileSync(cachePath(root), "utf8"));
+    if (raw.version === CACHE_VERSION && raw.manifestHash === key.manifestHash && raw.toolVersion === key.toolVersion && raw.offline === key.offline && raw.artifact) {
+      return { manifestHash: raw.manifestHash, artifact: raw.artifact };
+    }
+  } catch {
+  }
+  return null;
+}
+function writeScanCache(root, key, artifact) {
+  try {
+    fs4.mkdirSync(cacheDir(root), { recursive: true });
+    fs4.writeFileSync(
+      cachePath(root),
+      stableStringify(
+        { version: CACHE_VERSION, manifestHash: key.manifestHash, toolVersion: key.toolVersion, offline: key.offline, artifact },
+        0
+      )
+    );
+  } catch {
+  }
+}
+
+// src/runtime/vgd/freshness.ts
+var DEFAULT_SETTLE_MS = 600;
+var DEFAULT_MIN_REBUILD_GAP_MS = 5e3;
+var DEFAULT_REBUILD_TIMEOUT_MS = 10 * 6e4;
+var FreshnessSupervisor = class {
+  watched = /* @__PURE__ */ new Map();
+  /** Told when a manifest or lockfile is written — the shared dependency cache. */
+  manifestListener;
+  log;
+  reload;
+  select;
+  settleMs;
+  minRebuildGapMs;
+  rebuildTimeoutMs;
+  watchImpl;
+  rebuildImpl;
+  detectRef;
+  now;
+  constructor(options) {
+    this.log = options.log ?? (() => {
+    });
+    this.reload = options.reload;
+    this.select = options.select;
+    this.settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
+    this.minRebuildGapMs = options.minRebuildGapMs ?? DEFAULT_MIN_REBUILD_GAP_MS;
+    this.rebuildTimeoutMs = options.rebuildTimeoutMs ?? DEFAULT_REBUILD_TIMEOUT_MS;
+    this.watchImpl = options.watch ?? defaultWatch;
+    this.rebuildImpl = options.rebuild ?? ((root) => spawnRebuild(root, this.rebuildTimeoutMs));
+    this.detectRef = options.detectRef ?? defaultDetectRef;
+    this.now = options.now ?? (() => Date.now());
+  }
+  /**
+   * Attach something that must forget derived state when a manifest or
+   * lockfile changes. The watcher is already looking at exactly these files,
+   * so a cache hung off this has no staleness window — unlike a TTL.
+   */
+  setManifestListener(listener) {
+    this.manifestListener = listener;
+  }
+  list() {
+    return [...this.watched.values()].map((w) => ({
+      repositoryId: w.repositoryId,
+      root: w.root,
+      gitRef: w.gitRef,
+      watching: !!w.source,
+      pending: w.pending.size,
+      building: w.building,
+      lastRebuildAt: w.lastRebuildAt || void 0
+    })).sort((a, b) => a.repositoryId.localeCompare(b.repositoryId));
+  }
+  /**
+   * Start watching a repository. Idempotent: re-registering the same root only
+   * updates the ref it believes is current.
+   */
+  start(repositoryId, root, gitRef) {
+    const existing = this.watched.get(repositoryId);
+    if (existing) {
+      existing.gitRef = gitRef;
+      return;
+    }
+    const entry = {
+      repositoryId,
+      root,
+      gitRef,
+      source: null,
+      head: null,
+      timer: null,
+      pending: /* @__PURE__ */ new Set(),
+      building: false,
+      again: false,
+      lastRebuildAt: 0
+    };
+    this.watched.set(repositoryId, entry);
+    entry.source = this.watchImpl(root, (filename) => {
+      if (!isRelevantChange(filename)) return;
+      entry.pending.add(filename);
+      const manifest = isDependencyFile(root, path3.join(root, filename));
+      if (manifest) this.manifestListener?.(entry.repositoryId);
+      this.schedule(entry, manifest ? "manifest" : "source");
+    });
+    const gitDir = path3.join(root, ".git");
+    if (fs4.existsSync(gitDir)) {
+      entry.head = this.watchImpl(gitDir, (filename) => {
+        if (path3.basename(filename) !== "HEAD") return;
+        this.onHeadChanged(entry);
+      });
+    }
+    this.log(
+      `freshness: watching ${repositoryId} @${gitRef} (${entry.source ? "source" : "no source watcher"}${entry.head ? " + HEAD" : ""})`
+    );
+  }
+  /** Stop watching one repository — its slot is gone or was unregistered. */
+  stop(repositoryId) {
+    const entry = this.watched.get(repositoryId);
+    if (!entry) return;
+    this.watched.delete(repositoryId);
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.source?.close();
+    entry.head?.close();
+    this.log(`freshness: stopped watching ${repositoryId}`);
+  }
+  /** Daemon shutdown. */
+  stopAll() {
+    for (const id of [...this.watched.keys()]) this.stop(id);
+  }
+  /**
+   * A branch switch: re-select first, and rebuild only when that ref has no
+   * usable snapshot. Checking out a branch you were on ten minutes ago should
+   * be instant, not a full rebuild.
+   */
+  onHeadChanged(entry) {
+    const ref = this.detectRef(entry.root);
+    if (!ref || ref === entry.gitRef) return;
+    const from = entry.gitRef;
+    entry.gitRef = ref;
+    entry.pending.clear();
+    this.log(`freshness: ${entry.repositoryId} branch ${from} \u2192 ${ref}`);
+    this.select(entry.repositoryId, ref);
+    void this.reload(entry.repositoryId, entry.root, ref).then((nodes) => {
+      if (nodes != null) {
+        this.log(`freshness: ${entry.repositoryId}@${ref} slot warm from disk \u2014 ${nodes} nodes`);
+      } else {
+        this.log(`freshness: ${entry.repositoryId}@${ref} has no snapshot yet \u2014 rebuilding`);
+        this.schedule(entry, "branch");
+      }
+    });
+  }
+  schedule(entry, reason) {
+    if (entry.building) {
+      entry.again = true;
+      return;
+    }
+    if (entry.timer) clearTimeout(entry.timer);
+    const sinceLast = this.now() - entry.lastRebuildAt;
+    const wait = Math.max(this.settleMs, entry.lastRebuildAt ? this.minRebuildGapMs - sinceLast : 0);
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      void this.rebuild(entry, reason);
+    }, wait);
+    entry.timer.unref?.();
+  }
+  async rebuild(entry, reason) {
+    if (entry.building) {
+      entry.again = true;
+      return;
+    }
+    entry.building = true;
+    const changed = entry.pending.size;
+    const names = [...entry.pending].sort().slice(0, 3).join(", ");
+    entry.pending.clear();
+    const started = this.now();
+    this.log(
+      `freshness: rebuilding ${entry.repositoryId}@${entry.gitRef} (${reason}${changed ? `, ${changed} file(s): ${names}` : ""})\u2026`
+    );
+    try {
+      const result = await this.rebuildImpl(entry.root);
+      entry.lastRebuildAt = this.now();
+      if (!result.ok) {
+        this.log(`freshness: rebuild failed for ${entry.repositoryId} \u2014 ${result.error ?? "unknown"}; slot keeps its previous map`);
+        return;
+      }
+      const nodes = await this.reload(entry.repositoryId, entry.root, entry.gitRef);
+      this.log(
+        nodes != null ? `freshness: ${entry.repositoryId}@${entry.gitRef} reloaded \u2014 ${nodes} nodes in ${this.now() - started}ms` : `freshness: ${entry.repositoryId}@${entry.gitRef} rebuilt but no snapshot to reload`
+      );
+    } catch (err) {
+      this.log(`freshness: rebuild errored for ${entry.repositoryId} \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      entry.building = false;
+      if (entry.again) {
+        entry.again = false;
+        this.schedule(entry, "source");
+      }
+    }
+  }
+};
+function defaultDetectRef(root) {
+  clearDetectGitRefCache(root);
+  return detectGitRef(root).ref;
+}
+function defaultWatch(dir, onChange) {
+  try {
+    const w = fs4.watch(dir, { recursive: true }, (_event, filename) => {
+      if (filename) onChange(String(filename));
+    });
+    w.unref?.();
+    return w;
+  } catch {
+    return null;
+  }
+}
+function spawnRebuild(root, timeoutMs) {
+  return new Promise((resolve3) => {
+    let child;
+    try {
+      child = spawn(process.execPath, [process.argv[1] ?? "", "build", "-C", root, "--json", "--no-daemon", "--no-warm"], {
+        stdio: "ignore",
+        env: { ...process.env, NODE_OPTIONS: "" }
+      });
+    } catch (e) {
+      resolve3({ ok: false, error: e instanceof Error ? e.message : String(e) });
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      resolve3({ ok: false, error: `rebuild exceeded ${Math.round(timeoutMs / 1e3)}s` });
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve3({ ok: false, error: err.message });
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve3(code === 0 ? { ok: true } : { ok: false, error: `vg build exited ${code ?? "null"}` });
+    });
+  });
+}
+
+// src/runtime/vgd/dep-cache.ts
+var DepContextCache = class {
+  entries = /* @__PURE__ */ new Map();
+  log;
+  now;
+  computeHash;
+  computeInventory;
+  constructor(options = {}) {
+    this.log = options.log ?? (() => {
+    });
+    this.now = options.now ?? (() => Date.now());
+    this.computeHash = options.computeHash ?? manifestHash;
+    this.computeInventory = options.computeInventory ?? inventory;
+  }
+  /** Compute or reuse the context for a repository root. Never throws. */
+  get(repositoryId, root) {
+    const hit = this.entries.get(repositoryId);
+    if (hit) return hit;
+    const started = this.now();
+    try {
+      const context = {
+        manifestHash: this.computeHash(root),
+        inventory: this.computeInventory(root),
+        builtAt: this.now()
+      };
+      this.entries.set(repositoryId, context);
+      this.log(
+        `deps: context for ${repositoryId} built in ${context.builtAt - started}ms \u2014 ${context.inventory.records.length} dependency(ies)`
+      );
+      return context;
+    } catch (err) {
+      this.log(`deps: could not build context for ${repositoryId} \u2014 ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+  /**
+   * Forget a repository's context. Called from the freshness watcher when a
+   * manifest or lockfile is written, so the next reader recomputes.
+   */
+  invalidate(repositoryId) {
+    if (this.entries.delete(repositoryId)) this.log(`deps: context for ${repositoryId} invalidated by a manifest change`);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  size() {
+    return this.entries.size;
+  }
+};
+
 // src/runtime/vgd/server.ts
 async function startVgdServer(options = {}) {
   const socketPath = options.socketPath ?? vgdSocketPath();
@@ -925,23 +1557,60 @@ async function startVgdServer(options = {}) {
   });
   const embedBroker = options.embedBroker ?? new EmbedBroker({ log });
   embedBroker.setGraphProvider((repositoryId, gitRef) => registry.graphs.get(repositoryId, gitRef)?.graph);
+  const freshness = options.freshness ?? new FreshnessSupervisor({
+    log,
+    reload: (repositoryId, root, gitRef) => {
+      const graph = loadGraph(root);
+      if (!graph) return Promise.resolve(null);
+      registry.putGraph(repositoryId, gitRef, graph);
+      return Promise.resolve(graph.nodes?.length ?? 0);
+    },
+    select: (repositoryId, gitRef) => registry.selectGitRef(repositoryId, gitRef)
+  });
+  const watchEnabled = options.watch !== false;
+  const depCache = options.depCache ?? new DepContextCache({ log });
+  freshness.setManifestListener((repositoryId) => depCache.invalidate(repositoryId));
+  embedBroker.setRootProvider((repositoryId) => registry.getById(repositoryId)?.root);
   registry.setSlotListener(embedBroker);
   const onShutdownRequest = options.onShutdownRequest;
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const pid = options.pid ?? process.pid;
   const startedAt = Date.now();
   if (!socketPath.startsWith("\\\\.\\pipe")) {
-    fs2.mkdirSync(path.dirname(socketPath), { recursive: true });
+    fs4.mkdirSync(path3.dirname(socketPath), { recursive: true });
     try {
-      fs2.unlinkSync(socketPath);
+      fs4.unlinkSync(socketPath);
     } catch {
     }
   } else {
-    fs2.mkdirSync(path.dirname(pidPath), { recursive: true });
-  }
+    fs4.mkdirSync(path3.dirname(pidPath), { recursive: true });
+  }
+  const subscribers = /* @__PURE__ */ new Map();
+  const broadcastSlot = (repositoryId, gitRef, graph) => {
+    if (!subscribers.size) return;
+    const frame = JSON.stringify({
+      ok: true,
+      event: "slot-changed",
+      repositoryId,
+      gitRef,
+      nodeCount: graph.nodes?.length ?? 0,
+      corpusHash: graph.provenance?.corpusHash ?? null
+    }) + "\n";
+    for (const [socket, filter] of subscribers) {
+      if (filter.repositoryId && filter.repositoryId !== repositoryId) continue;
+      try {
+        socket.write(frame);
+      } catch {
+        subscribers.delete(socket);
+      }
+    }
+  };
+  registry.setPublishListener(broadcastSlot);
   const server = net.createServer((socket) => {
     let buffer = "";
     socket.setEncoding("utf8");
+    socket.on("close", () => subscribers.delete(socket));
+    socket.on("error", () => subscribers.delete(socket));
     socket.on("data", (chunk) => {
       buffer += chunk;
       let nl;
@@ -950,7 +1619,23 @@ async function startVgdServer(options = {}) {
         buffer = buffer.slice(nl + 1);
         if (!line) continue;
         void Promise.resolve(
-          handleLine(line, { registry, hostBroker, embedBroker, now, pid, startedAt, socketPath, onShutdownRequest, log })
+          handleLine(line, {
+            registry,
+            hostBroker,
+            embedBroker,
+            freshness: watchEnabled ? freshness : void 0,
+            depCache,
+            subscribe: (repositoryId) => {
+              subscribers.set(socket, { repositoryId });
+              log(`watch-slots: subscriber attached${repositoryId ? ` for ${repositoryId}` : " (all repositories)"}`);
+            },
+            now,
+            pid,
+            startedAt,
+            socketPath,
+            onShutdownRequest,
+            log
+          })
         ).then(
           (response) => {
             socket.write(JSON.stringify(response) + "\n");
@@ -959,16 +1644,16 @@ async function startVgdServer(options = {}) {
       }
     });
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server.once("error", reject);
     server.listen(socketPath, () => {
       server.off("error", reject);
-      resolve2();
+      resolve3();
     });
   });
   try {
-    fs2.mkdirSync(path.dirname(pidPath), { recursive: true });
-    fs2.writeFileSync(pidPath, `${pid}
+    fs4.mkdirSync(path3.dirname(pidPath), { recursive: true });
+    fs4.writeFileSync(pidPath, `${pid}
 `, "utf8");
   } catch {
   }
@@ -978,14 +1663,17 @@ async function startVgdServer(options = {}) {
     startedAt,
     async close() {
       embedBroker.stop();
-      await new Promise((resolve2) => server.close(() => resolve2()));
+      freshness.stopAll();
+      depCache.clear();
+      subscribers.clear();
+      await new Promise((resolve3) => server.close(() => resolve3()));
       try {
-        fs2.unlinkSync(pidPath);
+        fs4.unlinkSync(pidPath);
       } catch {
       }
       if (!socketPath.startsWith("\\\\.\\pipe")) {
         try {
-          fs2.unlinkSync(socketPath);
+          fs4.unlinkSync(socketPath);
         } catch {
         }
       }
@@ -1007,7 +1695,8 @@ async function handleLine(line, ctx) {
         graphSlots: ctx.registry.graphs.size(),
         version: VGD_PROTOCOL_VERSION,
         socketPath: ctx.socketPath,
-        cliVersion: VERSION
+        cliVersion: VERSION,
+        freshness: ctx.freshness?.list() ?? []
       };
     case "shutdown": {
       if (!ctx.onShutdownRequest) {
@@ -1041,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,
@@ -1052,6 +1754,76 @@ async function handleLine(line, ctx) {
         buildMs: idx.buildMs
       };
     }
+    case "embed-rank": {
+      const gitRef = req.gitRef ?? ctx.registry.graphs.selectedRef(req.repositoryId);
+      if (!gitRef) return { ok: false, error: "no current gitRef for this repository", code: "no_slot" };
+      const slot = ctx.registry.graphs.get(req.repositoryId, gitRef);
+      if (!slot) {
+        return { ok: false, error: `no graph slot for ${req.repositoryId}@${gitRef} \u2014 publish the map first`, code: "no_slot" };
+      }
+      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) {
+        return { ok: false, error: "semantic unavailable \u2014 rank lexically", code: "semantic_unavailable" };
+      }
+      return {
+        ok: true,
+        ranked: result.ranked,
+        repositoryId: req.repositoryId,
+        gitRef,
+        state: result.state,
+        vectors: result.vectors,
+        model: ctx.embedBroker.status().model,
+        rankMs: Date.now() - started
+      };
+    }
+    case "watch-slots": {
+      if (!ctx.subscribe) {
+        return { ok: false, error: "this listener does not support subscriptions", code: "unsupported" };
+      }
+      ctx.subscribe(req.repositoryId);
+      return { ok: true, watching: true, repositoryId: req.repositoryId };
+    }
+    case "dep-context": {
+      const record = ctx.registry.getById(req.repositoryId);
+      if (!record) {
+        return { ok: false, error: `unknown repository ${req.repositoryId} \u2014 register it first`, code: "not_found" };
+      }
+      const context = ctx.depCache.get(req.repositoryId, record.root);
+      if (!context) {
+        return { ok: false, error: "could not read this repository\u2019s manifests", code: "no_deps" };
+      }
+      return {
+        ok: true,
+        repositoryId: req.repositoryId,
+        manifestHash: context.manifestHash,
+        dependencies: context.inventory.records.map((r) => ({
+          name: r.name,
+          ecosystem: r.ecosystem,
+          declared: r.declared,
+          installed: r.installed
+        })),
+        builtAt: context.builtAt
+      };
+    }
     case "host-status":
       return { ok: true, host: ctx.hostBroker.status() };
     case "host-load": {
@@ -1100,8 +1872,11 @@ async function handleLine(line, ctx) {
       }
       return { ok: true, workspace };
     }
-    case "unregister":
+    case "unregister": {
+      const record = ctx.registry.get(req.root);
+      if (record) ctx.freshness?.stop(record.id);
       return { ok: true, removed: ctx.registry.unregister(req.root) };
+    }
     case "register-federation": {
       const workspaces = ctx.registry.registerFederation(req.members, ctx.now);
       return { ok: true, workspaces, federation: true };
@@ -1123,6 +1898,7 @@ async function handleLine(line, ctx) {
         const graph = req.graph;
         ctx.log(`put-graph: ${req.repositoryId}@${req.gitRef} \xB7 ${graph.nodes?.length ?? 0} nodes`);
         ctx.registry.putGraph(req.repositoryId, req.gitRef, graph);
+        startWatching(ctx, req.repositoryId, req.gitRef);
         return {
           ok: true,
           stored: true,
@@ -1147,6 +1923,7 @@ async function handleLine(line, ctx) {
         };
       }
       ctx.registry.putGraph(record.id, gitRef, graph);
+      startWatching(ctx, record.id, gitRef);
       return {
         ok: true,
         stored: true,
@@ -1160,13 +1937,27 @@ async function handleLine(line, ctx) {
       if (!resolved) {
         return { ok: false, error: "no ActiveGraph loaded for repository \u2014 put-graph first", code: "no_graph" };
       }
-      const result = queryGraph(resolved.graph, req.query, { limit: req.limit ?? 12, budget: 2e3 });
+      const limit = req.limit ?? 12;
+      let mode = "lexical";
+      let result = queryGraph(resolved.graph, req.query, { limit, budget: 2e3 });
+      if (req.semantic) {
+        const ranking = await ctx.embedBroker.rank(req.repositoryId, resolved.gitRef, req.query);
+        if (ranking && ranking.ranked.length) {
+          result = await queryGraphSemantic(resolved.graph, req.query, {
+            limit,
+            budget: 2e3,
+            semanticRanked: ranking.ranked
+          });
+          mode = `semantic (vgd${ctx.embedBroker.status().model ? `, ${ctx.embedBroker.status().model}` : ""})`;
+        }
+      }
       return {
         ok: true,
         query: req.query,
         repositoryId: req.repositoryId,
         gitRef: resolved.gitRef,
-        matches: result.matches.slice(0, req.limit ?? 12).map((m) => ({
+        mode,
+        matches: result.matches.slice(0, limit).map((m) => ({
           id: m.node.id,
           qualifiedName: m.node.qualifiedName,
           kind: m.node.kind,
@@ -1229,6 +2020,10 @@ async function handleLine(line, ctx) {
     }
   }
 }
+function startWatching(ctx, repositoryId, gitRef) {
+  const record = ctx.registry.getById(repositoryId);
+  if (record) ctx.freshness?.start(repositoryId, record.root, gitRef);
+}
 function resolveSymbol(graph, symbol) {
   if (graph.nodes.some((n) => n.id === symbol)) return { id: symbol };
   const hit = resolveOne(graph, symbol);
@@ -1315,6 +2110,6 @@ var BranchGraphSession = class {
   }
 };
 
-export { ActiveGraphCache, BranchGraphSession, DEFAULT_ACTIVE_GRAPH_IDLE_MS, VGD_PROTOCOL_VERSION, WorkspaceRegistry, parseRequest, startVgdServer };
-//# sourceMappingURL=chunk-GOGMS3ST.js.map
-//# sourceMappingURL=chunk-GOGMS3ST.js.map
+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-VQ5KMHW6.js.map
+//# sourceMappingURL=chunk-VQ5KMHW6.js.map