@vibgrate/cli 2026.803.1 → 2026.803.4

package/dist/{chunk-B2KLJPFY.js → chunk-4ZMJKR74.js}

@@ -1,13 +1,15 @@
-import { listHostSessions, hostSessionPoolSize, acquireHostSession, evictIdleSessions, clearHostSessionPool, dropHostSession, generateOnSession } from './chunk-3LOWJSAF.js';
 import { vgdSocketPath, vgdPidPath } from './chunk-RBIRXQR6.js';
+import { listHostSessions, hostSessionPoolSize, acquireHostSession, evictIdleSessions, clearHostSessionPool, dropHostSession, generateOnSession } from './chunk-3LOWJSAF.js';
 import { resolveOne } from './chunk-J7LKEB2R.js';
-import { impactOf, queryGraph } from './chunk-5VH3Y4QC.js';
-import { loadGraph } from './chunk-DIU3MXB3.js';
+import { impactOf, queryGraph } from './chunk-TVRM57CE.js';
+import { loadGraph } from './chunk-537JBQVB.js';
 import { repositoryIdFromRoot, globalGraphPathForRef, globalGraphPath } from './chunk-BWPBB45M.js';
 import { activeGraphSlotKey, detectGitRef } from './chunk-BPF3YX2U.js';
 import * as path from 'path';
-import * as fs from 'fs';
+import * as fs2 from 'fs';
 import * as net from 'net';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
 
 // src/runtime/vgd/protocol.ts
 var VGD_PROTOCOL_VERSION = "vgd/0";
@@ -56,6 +58,28 @@ function parseRequest(line) {
       graphPath: typeof graphPath === "string" && graphPath.trim() ? graphPath.trim() : void 0
     };
   }
+  if (op === "embed-status") {
+    const repositoryId = raw.repositoryId;
+    return {
+      op: "embed-status",
+      repositoryId: typeof repositoryId === "string" && repositoryId.trim() ? repositoryId.trim() : void 0
+    };
+  }
+  if (op === "embed-query") {
+    const text = raw.text;
+    if (typeof text !== "string" || !text.trim()) return { error: "embed-query requires text" };
+    return { op: "embed-query", text: text.trim().slice(0, 8e3) };
+  }
+  if (op === "embed-index") {
+    const repositoryId = raw.repositoryId;
+    const gitRef = raw.gitRef;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "embed-index requires repositoryId" };
+    return {
+      op: "embed-index",
+      repositoryId: repositoryId.trim(),
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0
+    };
+  }
   if (op === "query-graph") {
     const repositoryId = raw.repositoryId;
     const query = raw.query;
@@ -186,7 +210,9 @@ var ActiveGraphCache = class {
   maxPerRepo;
   maxTotal;
   now;
+  onEvict;
   constructor(options = {}) {
+    this.onEvict = options.onEvict;
     this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_ACTIVE_GRAPH_IDLE_MS;
     this.maxPerRepo = options.maxPerRepo ?? 8;
     this.maxTotal = options.maxTotal ?? 32;
@@ -276,9 +302,17 @@ var ActiveGraphCache = class {
     );
   }
   clear() {
+    for (const slot of this.slots.values()) this.notifyEvict(slot);
     this.slots.clear();
     this.currentRef.clear();
   }
+  notifyEvict(slot) {
+    if (!this.onEvict) return;
+    try {
+      this.onEvict({ repositoryId: slot.repositoryId, gitRef: slot.gitRef });
+    } catch {
+    }
+  }
   evict(now, forceOverflow) {
     const removed = [];
     const removeKey = (key) => {
@@ -286,6 +320,7 @@ var ActiveGraphCache = class {
       if (!slot) return;
       this.slots.delete(key);
       removed.push(key);
+      this.notifyEvict(slot);
     };
     const idle = this.idleCandidates(now, this.idleTimeoutMs);
     idle.sort((a, b) => a.loadedAt - b.loadedAt);
@@ -343,8 +378,21 @@ var ActiveGraphCache = class {
 // src/runtime/vgd/registry.ts
 var WorkspaceRegistry = class {
   byId = /* @__PURE__ */ new Map();
+  /**
+   * Anything keyed by the same (repositoryId, gitRef) slot as the graph — the
+   * semantic index — attaches here. Wiring it through the registry rather than
+   * the cache directly means every put/select/evict passes one funnel, so an
+   * index can never describe a ref its graph no longer holds.
+   */
+  slotListener;
   /** Multi-branch in-memory graphs (shared across registered workspaces). */
-  graphs = new ActiveGraphCache();
+  graphs = new ActiveGraphCache({
+    onEvict: (slot) => this.slotListener?.onGraphEvict(slot.repositoryId, slot.gitRef)
+  });
+  /** Attach the semantic index (or any slot-scoped resource) to graph lifecycle. */
+  setSlotListener(listener) {
+    this.slotListener = listener;
+  }
   register(root, now = () => /* @__PURE__ */ new Date(), meta = {}) {
     const resolved = path.resolve(root);
     const id = repositoryIdFromRoot(resolved);
@@ -370,10 +418,13 @@ var WorkspaceRegistry = class {
   putGraph(repositoryId, gitRef, graph) {
     this.graphs.put(repositoryId, gitRef, graph);
     this.graphs.select(repositoryId, gitRef);
+    this.slotListener?.onGraphPut(repositoryId, gitRef, graph);
+    this.slotListener?.onGraphSelect(repositoryId, gitRef);
   }
   /** Switch the current branch slot for a repository (no load). */
   selectGitRef(repositoryId, gitRef) {
     this.graphs.select(repositoryId, gitRef);
+    this.slotListener?.onGraphSelect(repositoryId, gitRef);
   }
   /** Register every member of a federation (primary + members). */
   registerFederation(members, now = () => /* @__PURE__ */ new Date()) {
@@ -430,8 +481,8 @@ var VgdHostBroker = class {
   }
   status() {
     const leases = {};
-    for (const [path3, clients] of this.leases) {
-      leases[path3] = clients.size;
+    for (const [path4, clients] of this.leases) {
+      leases[path4] = clients.size;
     }
     return {
       poolSize: hostSessionPoolSize(),
@@ -530,6 +581,338 @@ 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;
+  gaveUp = false;
+  crashes = 0;
+  reason;
+  model;
+  nextId = 1;
+  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();
+  /** The slot most recently made current — logged on change. */
+  currentKey;
+  graphProvider;
+  log;
+  spawnWorker;
+  maxCrashes;
+  requestTimeoutMs;
+  batchSize;
+  now;
+  constructor(options = {}) {
+    this.log = options.log ?? (() => {
+    });
+    this.spawnWorker = options.spawnWorker ?? defaultSpawnWorker;
+    this.maxCrashes = options.maxCrashes ?? 3;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 12e4;
+    this.batchSize = options.batchSize ?? 256;
+    this.now = options.now ?? (() => Date.now());
+  }
+  status() {
+    return {
+      worker: this.gaveUp ? "unavailable" : this.child ? "ready" : this.starting ? "starting" : "stopped",
+      pid: this.child?.pid,
+      model: this.model,
+      crashes: this.crashes,
+      reason: this.reason,
+      slots: this.listSlots()
+    };
+  }
+  listSlots(repositoryId) {
+    const out = [];
+    for (const idx of this.indexes.values()) {
+      if (repositoryId && idx.repositoryId !== repositoryId) continue;
+      out.push({
+        repositoryId: idx.repositoryId,
+        gitRef: idx.gitRef,
+        state: idx.state,
+        vectors: idx.vectors.size,
+        nodeCount: idx.nodeCount,
+        builtAt: idx.builtAt,
+        buildMs: idx.buildMs,
+        error: idx.error
+      });
+    }
+    return out.sort((a, b) => a.repositoryId.localeCompare(b.repositoryId) || a.gitRef.localeCompare(b.gitRef));
+  }
+  slot(repositoryId, gitRef) {
+    return this.indexes.get(activeGraphSlotKey(repositoryId, gitRef));
+  }
+  /** True once the broker has stopped trying — callers should go lexical. */
+  unavailable() {
+    return this.gaveUp;
+  }
+  /**
+   * A graph slot was published or replaced. The vectors for that slot no
+   * longer describe its graph, so they are dropped and a rebuild is queued.
+   * Called from the same funnel that stores the graph, so the two can never
+   * disagree about which ref they belong to.
+   */
+  onGraphPut(repositoryId, gitRef, graph) {
+    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)`);
+    }
+    this.indexes.set(key, {
+      repositoryId,
+      gitRef,
+      state: "stale",
+      vectors: /* @__PURE__ */ new Map(),
+      nodeCount
+    });
+  }
+  /**
+   * Supplies the graph for a slot so a select can warm without the caller
+   * threading it through. Set by the daemon to read its own cache.
+   */
+  setGraphProvider(provider) {
+    this.graphProvider = 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
+   * not ready, so the first Ask after a switch is not the one that pays.
+   */
+  onGraphSelect(repositoryId, gitRef) {
+    const key = activeGraphSlotKey(repositoryId, gitRef);
+    if (this.currentKey !== key) {
+      this.currentKey = key;
+      const idx2 = this.indexes.get(key);
+      this.log(
+        `semantic: current slot \u2192 ${repositoryId}@${gitRef} \xB7 index ${idx2 ? `${idx2.state} (${idx2.vectors.size} vectors)` : "absent"}`
+      );
+    }
+    if (this.gaveUp) return;
+    const idx = this.indexes.get(key);
+    if (idx?.state === "ready" || this.building.has(key)) return;
+    const graph = this.graphProvider?.(repositoryId, gitRef);
+    if (!graph) return;
+    void this.ensureIndex(repositoryId, gitRef, graph);
+  }
+  /** A graph slot was evicted — its index goes with it, never outliving it. */
+  onGraphEvict(repositoryId, gitRef) {
+    const key = activeGraphSlotKey(repositoryId, gitRef);
+    const idx = this.indexes.get(key);
+    if (!idx) return;
+    this.indexes.delete(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();
+  }
+  /**
+   * Ensure the slot has vectors, building them if needed. Resolves when the
+   * index is ready or has definitively failed; never throws.
+   */
+  async ensureIndex(repositoryId, gitRef, graph) {
+    const key = activeGraphSlotKey(repositoryId, gitRef);
+    let idx = this.indexes.get(key);
+    if (!idx) {
+      idx = { repositoryId, gitRef, state: "stale", vectors: /* @__PURE__ */ new Map(), nodeCount: graph.nodes?.length ?? 0 };
+      this.indexes.set(key, idx);
+    }
+    if (idx.state === "ready") return idx;
+    if (this.gaveUp) {
+      idx.state = "failed";
+      idx.error = this.reason ?? "embedding worker unavailable";
+      return idx;
+    }
+    if (this.building.has(key)) return idx;
+    this.building.add(key);
+    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`);
+    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) => {
+          const v = out[j];
+          if (v) vectors.set(n.id, v);
+        });
+        const live = this.indexes.get(key);
+        if (!live || live !== idx) {
+          this.log(`semantic: index build for ${repositoryId}@${gitRef} abandoned \u2014 slot changed underneath it`);
+          return idx;
+        }
+      }
+      idx.vectors = vectors;
+      idx.nodeCount = nodes.length;
+      idx.state = "ready";
+      idx.builtAt = this.now();
+      idx.buildMs = idx.builtAt - started;
+      idx.error = void 0;
+      this.log(`semantic: index ready for ${repositoryId}@${gitRef} \u2014 ${vectors.size} vectors in ${idx.buildMs}ms`);
+    } catch (err) {
+      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;
+  }
+  /** Embed one query string. Returns null when semantic is not available. */
+  async embedQuery(text) {
+    if (this.gaveUp) return null;
+    try {
+      const [vector] = await this.embed([text], true);
+      return vector ?? null;
+    } catch (err) {
+      this.log(`semantic: query embedding failed \u2014 ${err instanceof Error ? err.message : String(err)}; using lexical`);
+      return null;
+    }
+  }
+  /** Stop the worker (daemon shutdown). Safe to call when already stopped. */
+  stop() {
+    const child = this.child;
+    this.child = null;
+    this.starting = false;
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error("embedding worker stopped"));
+    }
+    this.pending.clear();
+    if (child) {
+      try {
+        child.kill();
+      } catch {
+      }
+    }
+  }
+  // ── worker plumbing ────────────────────────────────────────────────────
+  ensureWorker() {
+    if (this.child) return this.child;
+    this.starting = true;
+    const child = this.spawnWorker();
+    this.child = child;
+    this.starting = false;
+    this.buffer = "";
+    this.log(`semantic: embedding worker started (pid ${child.pid ?? "?"})`);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => this.onData(chunk));
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      const text = String(chunk).trim();
+      if (text) this.log(`semantic worker: ${text.slice(0, 500)}`);
+    });
+    child.on("exit", (code, signal) => this.onExit(code, signal));
+    child.on("error", (err) => {
+      this.log(`semantic: embedding worker could not start \u2014 ${err.message}`);
+      this.onExit(null, null);
+    });
+    return child;
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, nl).trim();
+      this.buffer = this.buffer.slice(nl + 1);
+      if (!line) continue;
+      let res;
+      try {
+        res = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (typeof res.model === "string") this.model = res.model;
+      const id = res.id;
+      if (typeof id !== "number") continue;
+      const p = this.pending.get(id);
+      if (!p) continue;
+      this.pending.delete(id);
+      clearTimeout(p.timer);
+      if (res.ok && Array.isArray(res.vectors)) p.resolve(res.vectors);
+      else p.reject(new Error(res.error || "embedding worker returned no vectors"));
+    }
+  }
+  onExit(code, signal) {
+    const wasRunning = !!this.child;
+    this.child = null;
+    if (!wasRunning) return;
+    this.crashes++;
+    const how = signal ? `signal ${signal}` : `code ${code ?? "null"}`;
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error(`embedding worker exited (${how})`));
+    }
+    this.pending.clear();
+    if (this.crashes >= this.maxCrashes) {
+      this.gaveUp = true;
+      this.reason = `the embedding worker exited (${how}) ${this.crashes} times \u2014 semantic search is off for this daemon; everything falls back to lexical. A native backend that aborts like this is usually a blocked onnxruntime-node postinstall (see \`vg embed --where\`).`;
+      this.log(`semantic: ${this.reason}`);
+      return;
+    }
+    this.log(`semantic: embedding worker exited (${how}) \u2014 restarting on next use (${this.crashes}/${this.maxCrashes})`);
+  }
+  embed(texts, query = false) {
+    if (this.gaveUp) return Promise.reject(new Error(this.reason ?? "embedding worker unavailable"));
+    if (!texts.length) return Promise.resolve([]);
+    let child;
+    try {
+      child = this.ensureWorker();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.crashes++;
+      if (this.crashes >= this.maxCrashes) {
+        this.gaveUp = true;
+        this.reason = `the embedding worker could not start (${error.message}) \u2014 semantic search is off for this daemon`;
+        this.log(`semantic: ${this.reason}`);
+      } else {
+        this.log(`semantic: embedding worker could not start \u2014 ${error.message} (${this.crashes}/${this.maxCrashes})`);
+      }
+      return Promise.reject(error);
+    }
+    const id = this.nextId++;
+    return new Promise((resolve2, 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 });
+      try {
+        child.stdin?.write(JSON.stringify({ id, op: "embed", texts, query }) + "\n");
+      } catch (err) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  /** A successful exchange clears the crash streak — used after a good build. */
+  noteHealthy() {
+    this.crashes = 0;
+  }
+};
+function defaultSpawnWorker() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const entry = path.join(here, "embed-worker-main.js");
+  if (!fs2.existsSync(entry)) {
+    throw new Error(`embedding worker not found at ${entry} \u2014 semantic runs lexically`);
+  }
+  return spawn(process.execPath, [entry], {
+    stdio: ["pipe", "pipe", "pipe"],
+    // Never inherit loader flags or a debugger port: this child exists to be
+    // expendable, and anything that changes how it loads defeats the point.
+    env: { ...process.env, NODE_OPTIONS: "" }
+  });
+}
 
 // src/runtime/vgd/server.ts
 async function startVgdServer(options = {}) {
@@ -537,18 +920,23 @@ async function startVgdServer(options = {}) {
   const pidPath = options.pidPath ?? vgdPidPath();
   const registry = options.registry ?? new WorkspaceRegistry();
   const hostBroker = options.hostBroker ?? getVgdHostBroker();
+  const log = options.log ?? (() => {
+  });
+  const embedBroker = options.embedBroker ?? new EmbedBroker({ log });
+  embedBroker.setGraphProvider((repositoryId, gitRef) => registry.graphs.get(repositoryId, gitRef)?.graph);
+  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")) {
-    fs.mkdirSync(path.dirname(socketPath), { recursive: true });
+    fs2.mkdirSync(path.dirname(socketPath), { recursive: true });
     try {
-      fs.unlinkSync(socketPath);
+      fs2.unlinkSync(socketPath);
     } catch {
     }
   } else {
-    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
+    fs2.mkdirSync(path.dirname(pidPath), { recursive: true });
   }
   const server = net.createServer((socket) => {
     let buffer = "";
@@ -561,7 +949,7 @@ async function startVgdServer(options = {}) {
         buffer = buffer.slice(nl + 1);
         if (!line) continue;
         void Promise.resolve(
-          handleLine(line, { registry, hostBroker, now, pid, startedAt, socketPath, onShutdownRequest })
+          handleLine(line, { registry, hostBroker, embedBroker, now, pid, startedAt, socketPath, onShutdownRequest, log })
         ).then(
           (response) => {
             socket.write(JSON.stringify(response) + "\n");
@@ -578,8 +966,8 @@ async function startVgdServer(options = {}) {
     });
   });
   try {
-    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
-    fs.writeFileSync(pidPath, `${pid}
+    fs2.mkdirSync(path.dirname(pidPath), { recursive: true });
+    fs2.writeFileSync(pidPath, `${pid}
 `, "utf8");
   } catch {
   }
@@ -588,14 +976,15 @@ async function startVgdServer(options = {}) {
     registry,
     startedAt,
     async close() {
+      embedBroker.stop();
       await new Promise((resolve2) => server.close(() => resolve2()));
       try {
-        fs.unlinkSync(pidPath);
+        fs2.unlinkSync(pidPath);
       } catch {
       }
       if (!socketPath.startsWith("\\\\.\\pipe")) {
         try {
-          fs.unlinkSync(socketPath);
+          fs2.unlinkSync(socketPath);
         } catch {
         }
       }
@@ -630,6 +1019,37 @@ async function handleLine(line, ctx) {
       setTimeout(() => hook(), 150);
       return { ok: true, stopping: true };
     }
+    case "embed-status":
+      return { ok: true, semantic: ctx.embedBroker.status() };
+    case "embed-query": {
+      const vector = await ctx.embedBroker.embedQuery(req.text);
+      if (!vector) {
+        return {
+          ok: false,
+          error: "semantic unavailable \u2014 rank lexically",
+          code: "semantic_unavailable"
+        };
+      }
+      return { ok: true, vector, model: ctx.embedBroker.status().model };
+    }
+    case "embed-index": {
+      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 idx = await ctx.embedBroker.ensureIndex(req.repositoryId, gitRef, slot.graph);
+      return {
+        ok: true,
+        indexed: true,
+        repositoryId: req.repositoryId,
+        gitRef,
+        state: idx.state,
+        vectors: idx.vectors.size,
+        buildMs: idx.buildMs
+      };
+    }
     case "host-status":
       return { ok: true, host: ctx.hostBroker.status() };
     case "host-load": {
@@ -670,11 +1090,14 @@ async function handleLine(line, ctx) {
     }
     case "list":
       return { ok: true, workspaces: ctx.registry.list() };
-    case "register":
-      return {
-        ok: true,
-        workspace: ctx.registry.register(req.root, ctx.now, { label: req.label, role: req.role })
-      };
+    case "register": {
+      const known = ctx.registry.size();
+      const workspace = ctx.registry.register(req.root, ctx.now, { label: req.label, role: req.role });
+      if (ctx.registry.size() > known) {
+        ctx.log(`register: new workspace ${workspace.id} (${workspace.root}${workspace.gitRef ? ` @${workspace.gitRef}` : ""})`);
+      }
+      return { ok: true, workspace };
+    }
     case "unregister":
       return { ok: true, removed: ctx.registry.unregister(req.root) };
     case "register-federation": {
@@ -686,12 +1109,17 @@ async function handleLine(line, ctx) {
       return { ok: true, slots: ctx.registry.graphs.list(req.repositoryId) };
     }
     case "select-git-ref": {
+      const before = ctx.registry.graphs.selectedRef(req.repositoryId);
+      if (before !== req.gitRef) {
+        ctx.log(`select-git-ref: ${req.repositoryId} ${before ?? "(none)"} \u2192 ${req.gitRef}`);
+      }
       ctx.registry.selectGitRef(req.repositoryId, req.gitRef);
       return { ok: true, selected: true, repositoryId: req.repositoryId, gitRef: req.gitRef };
     }
     case "put-graph": {
       try {
         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);
         return {
           ok: true,
@@ -707,6 +1135,7 @@ async function handleLine(line, ctx) {
     case "load-graph": {
       const record = ctx.registry.register(req.root, ctx.now, { gitRef: req.gitRef });
       const gitRef = req.gitRef ?? record.gitRef ?? "HEAD";
+      ctx.log(`load-graph: ${record.id}@${gitRef} from ${req.root}`);
       const graph = loadGraph(req.root, req.graphPath);
       if (!graph) {
         return {
@@ -885,5 +1314,5 @@ var BranchGraphSession = class {
 };
 
 export { ActiveGraphCache, BranchGraphSession, DEFAULT_ACTIVE_GRAPH_IDLE_MS, VGD_PROTOCOL_VERSION, WorkspaceRegistry, parseRequest, startVgdServer };
-//# sourceMappingURL=chunk-B2KLJPFY.js.map
-//# sourceMappingURL=chunk-B2KLJPFY.js.map
+//# sourceMappingURL=chunk-4ZMJKR74.js.map
+//# sourceMappingURL=chunk-4ZMJKR74.js.map