@vibgrate/cli 2026.722.2 → 2026.727.1

package/dist/chunk-SZLF66FJ.js

@@ -0,0 +1,843 @@
+import { vgdSocketPath, vgdPidPath } from './chunk-PMYWZRRS.js';
+import { listHostSessions, hostSessionPoolSize, acquireHostSession, evictIdleSessions, clearHostSessionPool, dropHostSession, generateOnSession } from './chunk-K7REHDQS.js';
+import { resolveOne } from './chunk-J7LKEB2R.js';
+import { impactOf, queryGraph } from './chunk-6IOQJGFT.js';
+import { loadGraph } from './chunk-HABUT7HW.js';
+import { parseGraph } from './chunk-5Q54GEHM.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 net from 'net';
+
+// src/runtime/vgd/protocol.ts
+var VGD_PROTOCOL_VERSION = "vgd/0";
+function parseRequest(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    return { error: "invalid JSON" };
+  }
+  if (!raw || typeof raw !== "object") return { error: "request must be an object" };
+  const op = raw.op;
+  if (op === "ping" || op === "status" || op === "list") return { op };
+  if (op === "list-graph-slots") {
+    const repositoryId = raw.repositoryId;
+    return {
+      op: "list-graph-slots",
+      repositoryId: typeof repositoryId === "string" && repositoryId.trim() ? repositoryId.trim() : void 0
+    };
+  }
+  if (op === "select-git-ref") {
+    const repositoryId = raw.repositoryId;
+    const gitRef = raw.gitRef;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "select-git-ref requires repositoryId" };
+    if (typeof gitRef !== "string" || !gitRef.trim()) return { error: "select-git-ref requires gitRef" };
+    return { op: "select-git-ref", repositoryId: repositoryId.trim(), gitRef: gitRef.trim() };
+  }
+  if (op === "put-graph") {
+    const repositoryId = raw.repositoryId;
+    const gitRef = raw.gitRef;
+    const graph = raw.graph;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "put-graph requires repositoryId" };
+    if (typeof gitRef !== "string" || !gitRef.trim()) return { error: "put-graph requires gitRef" };
+    if (!graph || typeof graph !== "object") return { error: "put-graph requires graph object" };
+    return { op: "put-graph", repositoryId: repositoryId.trim(), gitRef: gitRef.trim(), graph };
+  }
+  if (op === "query-graph") {
+    const repositoryId = raw.repositoryId;
+    const query = raw.query;
+    const limit = raw.limit;
+    const gitRef = raw.gitRef;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "query-graph requires repositoryId" };
+    if (typeof query !== "string" || !query.trim()) return { error: "query-graph requires query" };
+    return {
+      op: "query-graph",
+      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
+    };
+  }
+  if (op === "impact-of") {
+    const repositoryId = raw.repositoryId;
+    const symbol = raw.symbol;
+    const depth = raw.depth;
+    const gitRef = raw.gitRef;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "impact-of requires repositoryId" };
+    if (typeof symbol !== "string" || !symbol.trim()) return { error: "impact-of requires symbol" };
+    return {
+      op: "impact-of",
+      repositoryId: repositoryId.trim(),
+      symbol: symbol.trim(),
+      depth: typeof depth === "number" && depth > 0 ? Math.min(Math.floor(depth), 12) : void 0,
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0
+    };
+  }
+  if (op === "graph-summary") {
+    const repositoryId = raw.repositoryId;
+    const gitRef = raw.gitRef;
+    if (typeof repositoryId !== "string" || !repositoryId.trim()) return { error: "graph-summary requires repositoryId" };
+    return {
+      op: "graph-summary",
+      repositoryId: repositoryId.trim(),
+      gitRef: typeof gitRef === "string" && gitRef.trim() ? gitRef.trim() : void 0
+    };
+  }
+  if (op === "register" || op === "unregister") {
+    const root = raw.root;
+    if (typeof root !== "string" || !root.trim()) return { error: `${op} requires a non-empty root` };
+    const label = raw.label;
+    const role = raw.role;
+    if (op === "register") {
+      return {
+        op: "register",
+        root: root.trim(),
+        label: typeof label === "string" ? label : void 0,
+        role: role === "primary" || role === "member" ? role : void 0
+      };
+    }
+    return { op: "unregister", root: root.trim() };
+  }
+  if (op === "register-federation") {
+    const primaryRoot = raw.primaryRoot;
+    const members = raw.members;
+    if (typeof primaryRoot !== "string" || !primaryRoot.trim()) return { error: "register-federation requires primaryRoot" };
+    if (!Array.isArray(members) || members.length === 0) return { error: "register-federation requires members[]" };
+    const parsed = [];
+    for (const m of members) {
+      if (!m || typeof m !== "object") continue;
+      const root = m.root;
+      if (typeof root !== "string" || !root.trim()) continue;
+      const label = m.label;
+      const role = m.role;
+      parsed.push({
+        root: root.trim(),
+        label: typeof label === "string" ? label : void 0,
+        role: role === "primary" || role === "member" ? role : void 0
+      });
+    }
+    if (!parsed.length) return { error: "register-federation members must include at least one root" };
+    return { op: "register-federation", primaryRoot: primaryRoot.trim(), members: parsed };
+  }
+  if (op === "host-status") return { op: "host-status" };
+  if (op === "host-load") {
+    const modelPath = raw.modelPath;
+    if (typeof modelPath !== "string" || !modelPath.trim()) return { error: "host-load requires modelPath" };
+    return { op: "host-load", modelPath: modelPath.trim() };
+  }
+  if (op === "host-unload") {
+    const modelPath = raw.modelPath;
+    return {
+      op: "host-unload",
+      modelPath: typeof modelPath === "string" && modelPath.trim() ? modelPath.trim() : void 0
+    };
+  }
+  if (op === "host-generate") {
+    const modelPath = raw.modelPath;
+    const messages = raw.messages;
+    if (typeof modelPath !== "string" || !modelPath.trim()) return { error: "host-generate requires modelPath" };
+    if (!Array.isArray(messages) || messages.length === 0) return { error: "host-generate requires messages[]" };
+    const parsed = [];
+    for (const m of messages) {
+      if (!m || typeof m !== "object") continue;
+      const role = m.role;
+      const content = m.content;
+      if (typeof role !== "string" || typeof content !== "string") continue;
+      parsed.push({ role, content });
+    }
+    if (!parsed.length) return { error: "host-generate messages must include role+content" };
+    const grammar = raw.grammar;
+    const requireGrammar = raw.requireGrammar;
+    const maxTokens = raw.maxTokens;
+    const temperature = raw.temperature;
+    return {
+      op: "host-generate",
+      modelPath: modelPath.trim(),
+      messages: parsed,
+      grammar: typeof grammar === "string" ? grammar : void 0,
+      requireGrammar: requireGrammar === true,
+      maxTokens: typeof maxTokens === "number" ? maxTokens : void 0,
+      temperature: typeof temperature === "number" ? temperature : void 0
+    };
+  }
+  return { error: `unknown op: ${String(op)}` };
+}
+
+// src/runtime/active-graph-cache.ts
+var DEFAULT_ACTIVE_GRAPH_IDLE_MS = 20 * 60 * 1e3;
+var ActiveGraphCache = class {
+  slots = /* @__PURE__ */ new Map();
+  /** repositoryId → currently selected gitRef */
+  currentRef = /* @__PURE__ */ new Map();
+  idleTimeoutMs;
+  maxPerRepo;
+  maxTotal;
+  now;
+  constructor(options = {}) {
+    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_ACTIVE_GRAPH_IDLE_MS;
+    this.maxPerRepo = options.maxPerRepo ?? 8;
+    this.maxTotal = options.maxTotal ?? 32;
+    this.now = options.now ?? (() => Date.now());
+  }
+  size() {
+    return this.slots.size;
+  }
+  get(repositoryId, gitRef) {
+    const slot = this.slots.get(activeGraphSlotKey(repositoryId, gitRef));
+    if (slot) {
+      slot.lastAccessAt = this.now();
+    }
+    return slot;
+  }
+  /**
+   * Insert or replace a graph for (repositoryId, gitRef). Touches access time.
+   * Runs eviction if over cap.
+   */
+  put(repositoryId, gitRef, graph) {
+    const key = activeGraphSlotKey(repositoryId, gitRef);
+    const t = this.now();
+    const existing = this.slots.get(key);
+    const slot = {
+      repositoryId,
+      gitRef,
+      graph,
+      loadedAt: existing?.loadedAt ?? t,
+      lastAccessAt: t,
+      nodeCount: graph.nodes?.length ?? 0
+    };
+    this.slots.set(key, slot);
+    if (!this.currentRef.has(repositoryId)) {
+      this.currentRef.set(repositoryId, gitRef);
+    }
+    this.evictIfNeeded();
+    return slot;
+  }
+  /**
+   * Mark gitRef as the current branch for this repository and touch it.
+   * Returns the slot if present.
+   */
+  select(repositoryId, gitRef) {
+    this.currentRef.set(repositoryId, gitRef);
+    return this.get(repositoryId, gitRef);
+  }
+  /** Currently selected gitRef for a repository, if any. */
+  selectedRef(repositoryId) {
+    return this.currentRef.get(repositoryId);
+  }
+  current(repositoryId) {
+    const ref = this.currentRef.get(repositoryId);
+    if (!ref) return void 0;
+    return this.get(repositoryId, ref);
+  }
+  /**
+   * Drop idle slots past the timeout (LILO among idle).
+   * Returns keys of removed slots.
+   */
+  evictIdle(now = this.now()) {
+    return this.evict(now, false);
+  }
+  /** Force eviction of idle slots when over caps (timeout may be ignored for overflow). */
+  evictIfNeeded() {
+    return this.evict(this.now(), true);
+  }
+  list(repositoryId) {
+    const t = this.now();
+    const out = [];
+    for (const slot of this.slots.values()) {
+      if (repositoryId && slot.repositoryId !== repositoryId) continue;
+      const current = this.currentRef.get(slot.repositoryId) === slot.gitRef;
+      const idleMs = t - slot.lastAccessAt;
+      out.push({
+        repositoryId: slot.repositoryId,
+        gitRef: slot.gitRef,
+        loadedAt: slot.loadedAt,
+        lastAccessAt: slot.lastAccessAt,
+        nodeCount: slot.nodeCount,
+        current,
+        idleMs,
+        evictable: !current && idleMs >= this.idleTimeoutMs
+      });
+    }
+    return out.sort(
+      (a, b) => a.repositoryId.localeCompare(b.repositoryId) || a.gitRef.localeCompare(b.gitRef)
+    );
+  }
+  clear() {
+    this.slots.clear();
+    this.currentRef.clear();
+  }
+  evict(now, forceOverflow) {
+    const removed = [];
+    const removeKey = (key) => {
+      const slot = this.slots.get(key);
+      if (!slot) return;
+      this.slots.delete(key);
+      removed.push(key);
+    };
+    const idle = this.idleCandidates(now, this.idleTimeoutMs);
+    idle.sort((a, b) => a.loadedAt - b.loadedAt);
+    for (const slot of idle) {
+      removeKey(activeGraphSlotKey(slot.repositoryId, slot.gitRef));
+    }
+    if (forceOverflow) {
+      while (this.slots.size > this.maxTotal) {
+        const victim = this.pickLiloVictim(
+          now,
+          /* requireIdleTimeout */
+          false
+        );
+        if (!victim) break;
+        removeKey(activeGraphSlotKey(victim.repositoryId, victim.gitRef));
+      }
+      const byRepo = /* @__PURE__ */ new Map();
+      for (const s of this.slots.values()) {
+        const list = byRepo.get(s.repositoryId) ?? [];
+        list.push(s);
+        byRepo.set(s.repositoryId, list);
+      }
+      for (const [repoId, list] of byRepo) {
+        if (list.length <= this.maxPerRepo) continue;
+        const nonCurrent = list.filter((s) => this.currentRef.get(repoId) !== s.gitRef).sort((a, b) => a.loadedAt - b.loadedAt);
+        let excess = list.length - this.maxPerRepo;
+        for (const s of nonCurrent) {
+          if (excess <= 0) break;
+          removeKey(activeGraphSlotKey(s.repositoryId, s.gitRef));
+          excess--;
+        }
+      }
+    }
+    return removed;
+  }
+  idleCandidates(now, timeoutMs) {
+    const out = [];
+    for (const slot of this.slots.values()) {
+      if (this.currentRef.get(slot.repositoryId) === slot.gitRef) continue;
+      if (now - slot.lastAccessAt >= timeoutMs) out.push(slot);
+    }
+    return out;
+  }
+  pickLiloVictim(now, requireIdleTimeout) {
+    let best = null;
+    for (const slot of this.slots.values()) {
+      if (this.currentRef.get(slot.repositoryId) === slot.gitRef) continue;
+      if (requireIdleTimeout && now - slot.lastAccessAt < this.idleTimeoutMs) continue;
+      if (!best || slot.loadedAt < best.loadedAt) best = slot;
+    }
+    return best;
+  }
+};
+
+// src/runtime/vgd/registry.ts
+var WorkspaceRegistry = class {
+  byId = /* @__PURE__ */ new Map();
+  /** Multi-branch in-memory graphs (shared across registered workspaces). */
+  graphs = new ActiveGraphCache();
+  register(root, now = () => /* @__PURE__ */ new Date(), meta = {}) {
+    const resolved = path.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);
+    const record = {
+      id,
+      root: resolved,
+      graphPath,
+      registeredAt: now().toISOString(),
+      label: meta.label,
+      role: meta.role,
+      gitRef: git.ref || void 0
+    };
+    this.byId.set(id, record);
+    if (git.ref) this.graphs.select(id, git.ref);
+    return record;
+  }
+  /**
+   * Activate or insert an in-memory graph for a workspace branch.
+   * Call after load/build; runs LILO idle eviction as needed.
+   */
+  putGraph(repositoryId, gitRef, graph) {
+    this.graphs.put(repositoryId, gitRef, graph);
+    this.graphs.select(repositoryId, gitRef);
+  }
+  /** Switch the current branch slot for a repository (no load). */
+  selectGitRef(repositoryId, gitRef) {
+    this.graphs.select(repositoryId, gitRef);
+  }
+  /** Register every member of a federation (primary + members). */
+  registerFederation(members, now = () => /* @__PURE__ */ new Date()) {
+    return members.map((m) => this.register(m.root, now, { label: m.label, role: m.role }));
+  }
+  unregister(root) {
+    const id = repositoryIdFromRoot(path.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)));
+  }
+  /** Lookup by stable repository id. */
+  getById(repositoryId) {
+    return this.byId.get(repositoryId);
+  }
+  size() {
+    return this.byId.size;
+  }
+  /**
+   * Resolve an ActiveGraph for query/impact: prefer the named gitRef, else the
+   * selected current slot, else any warm slot for the repository.
+   */
+  resolveGraph(repositoryId, gitRef) {
+    if (gitRef) {
+      const slot = this.graphs.get(repositoryId, gitRef);
+      if (slot) return { graph: slot.graph, gitRef: slot.gitRef };
+    }
+    const current = this.graphs.current(repositoryId);
+    if (current) return { graph: current.graph, gitRef: current.gitRef };
+    const any = this.graphs.list(repositoryId).slice().sort((a, b) => a.loadedAt - b.loadedAt)[0];
+    if (any) {
+      const slot = this.graphs.get(repositoryId, any.gitRef);
+      if (slot) return { graph: slot.graph, gitRef: slot.gitRef };
+    }
+    return null;
+  }
+};
+
+// src/runtime/vgd/host-broker.ts
+var VgdHostBroker = class {
+  binding = null;
+  loaded = /* @__PURE__ */ new Set();
+  /** modelPath → set of client ids holding a lease. */
+  leases = /* @__PURE__ */ new Map();
+  setBinding(lib) {
+    this.binding = lib;
+  }
+  hasBinding() {
+    return this.binding != null;
+  }
+  status() {
+    const leases = {};
+    for (const [path3, clients] of this.leases) {
+      leases[path3] = clients.size;
+    }
+    return {
+      poolSize: hostSessionPoolSize(),
+      loadedModels: [...this.loaded],
+      bindingReady: this.binding != null,
+      leases,
+      sessions: listHostSessions()
+    };
+  }
+  /**
+   * Load weights and optionally register a client lease (P4 multi-client).
+   * When clientId is omitted, behaves like a one-shot load (no lease bookkeeping).
+   */
+  async load(modelPath, clientId) {
+    if (!this.binding) {
+      return { ok: false, error: "host binding not configured \u2014 start vgd with llama runtime or attach binding" };
+    }
+    try {
+      await acquireHostSession(this.binding, modelPath);
+      this.loaded.add(modelPath);
+      if (clientId) {
+        let set = this.leases.get(modelPath);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.leases.set(modelPath, set);
+        }
+        set.add(clientId);
+      }
+      evictIdleSessions(4);
+      return { ok: true, modelPath, leases: this.leases.get(modelPath)?.size ?? 0 };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /**
+   * Release a client lease. When the last lease is released, drop the warm
+   * session for that path. Without clientId, clears all leases for the path
+   * (or entire pool if modelPath omitted).
+   */
+  async unload(modelPath, clientId) {
+    if (!modelPath) {
+      const n = hostSessionPoolSize();
+      clearHostSessionPool();
+      this.loaded.clear();
+      this.leases.clear();
+      return { ok: true, cleared: n, remainingLeases: 0 };
+    }
+    if (clientId) {
+      const set = this.leases.get(modelPath);
+      if (set) {
+        set.delete(clientId);
+        if (set.size === 0) this.leases.delete(modelPath);
+      }
+      const remaining = this.leases.get(modelPath)?.size ?? 0;
+      if (remaining === 0) {
+        const dropped2 = dropHostSession(modelPath) ? 1 : 0;
+        this.loaded.delete(modelPath);
+        return { ok: true, cleared: dropped2, remainingLeases: 0 };
+      }
+      return { ok: true, cleared: 0, remainingLeases: remaining };
+    }
+    this.leases.delete(modelPath);
+    const dropped = dropHostSession(modelPath) ? 1 : 0;
+    this.loaded.delete(modelPath);
+    return { ok: true, cleared: dropped, remainingLeases: 0 };
+  }
+  /** How many clients hold a lease on modelPath. */
+  leaseCount(modelPath) {
+    return this.leases.get(modelPath)?.size ?? 0;
+  }
+  async generate(modelPath, messages, opts) {
+    if (!this.binding) {
+      return { ok: false, error: "host binding not configured" };
+    }
+    try {
+      const session = await acquireHostSession(this.binding, modelPath);
+      this.loaded.add(modelPath);
+      const result = await generateOnSession(session, messages, {
+        grammar: opts?.grammar,
+        requireGrammar: opts?.requireGrammar,
+        identifierTrie: opts?.identifierTrie,
+        annotateUnknownIdentifiers: opts?.annotateUnknownIdentifiers,
+        draftCandidates: opts?.draftCandidates,
+        maxTokens: opts?.maxTokens,
+        temperature: opts?.temperature,
+        promptSegments: opts?.promptSegments
+      });
+      return { ok: true, result };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+};
+var defaultBroker = null;
+function getVgdHostBroker() {
+  if (!defaultBroker) defaultBroker = new VgdHostBroker();
+  return defaultBroker;
+}
+
+// src/runtime/vgd/server.ts
+async function startVgdServer(options = {}) {
+  const socketPath = options.socketPath ?? vgdSocketPath();
+  const pidPath = options.pidPath ?? vgdPidPath();
+  const registry = options.registry ?? new WorkspaceRegistry();
+  const hostBroker = options.hostBroker ?? getVgdHostBroker();
+  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 });
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+    }
+  } else {
+    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
+  }
+  const server = net.createServer((socket) => {
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        void Promise.resolve(handleLine(line, { registry, hostBroker, now, pid, startedAt, socketPath })).then(
+          (response) => {
+            socket.write(JSON.stringify(response) + "\n");
+          }
+        );
+      }
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.off("error", reject);
+      resolve2();
+    });
+  });
+  try {
+    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
+    fs.writeFileSync(pidPath, `${pid}
+`, "utf8");
+  } catch {
+  }
+  return {
+    socketPath,
+    registry,
+    startedAt,
+    async close() {
+      await new Promise((resolve2) => server.close(() => resolve2()));
+      try {
+        fs.unlinkSync(pidPath);
+      } catch {
+      }
+      if (!socketPath.startsWith("\\\\.\\pipe")) {
+        try {
+          fs.unlinkSync(socketPath);
+        } catch {
+        }
+      }
+    }
+  };
+}
+async function handleLine(line, ctx) {
+  const req = parseRequest(line);
+  if ("error" in req) return { ok: false, error: req.error, code: "bad_request" };
+  switch (req.op) {
+    case "ping":
+      return { ok: true, pong: true, version: VGD_PROTOCOL_VERSION };
+    case "status":
+      return {
+        ok: true,
+        pid: ctx.pid,
+        uptimeMs: Date.now() - ctx.startedAt,
+        workspaces: ctx.registry.size(),
+        graphSlots: ctx.registry.graphs.size(),
+        version: VGD_PROTOCOL_VERSION,
+        socketPath: ctx.socketPath
+      };
+    case "host-status":
+      return { ok: true, host: ctx.hostBroker.status() };
+    case "host-load": {
+      const r = await ctx.hostBroker.load(req.modelPath);
+      if (!r.ok) return { ok: false, error: r.error, code: "host_error" };
+      return { ok: true, hostLoaded: true, modelPath: r.modelPath };
+    }
+    case "host-unload": {
+      const r = await ctx.hostBroker.unload(req.modelPath);
+      return { ok: true, hostUnloaded: true, cleared: r.cleared };
+    }
+    case "host-generate": {
+      const r = await ctx.hostBroker.generate(
+        req.modelPath,
+        req.messages.map((m) => ({
+          role: m.role === "system" || m.role === "assistant" ? m.role : "user",
+          content: m.content
+        })),
+        {
+          grammar: req.grammar,
+          requireGrammar: req.requireGrammar,
+          maxTokens: req.maxTokens,
+          temperature: req.temperature
+        }
+      );
+      if (!r.ok) return { ok: false, error: r.error, code: "host_error" };
+      return {
+        ok: true,
+        hostGenerated: true,
+        text: r.result.text,
+        model: r.result.model,
+        constrained: r.result.constrained,
+        grammarApplied: r.result.grammarApplied,
+        draftAcceptedChars: r.result.draftAcceptedChars,
+        latencyMs: r.result.latencyMs,
+        unknownIdentifiers: r.result.unknownIdentifiers
+      };
+    }
+    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 "unregister":
+      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 };
+    }
+    case "list-graph-slots": {
+      ctx.registry.graphs.evictIdle();
+      return { ok: true, slots: ctx.registry.graphs.list(req.repositoryId) };
+    }
+    case "select-git-ref": {
+      ctx.registry.selectGitRef(req.repositoryId, req.gitRef);
+      return { ok: true, selected: true, repositoryId: req.repositoryId, gitRef: req.gitRef };
+    }
+    case "put-graph": {
+      try {
+        const graph = parseGraph(JSON.stringify(req.graph));
+        ctx.registry.putGraph(req.repositoryId, req.gitRef, graph);
+        return {
+          ok: true,
+          stored: true,
+          repositoryId: req.repositoryId,
+          gitRef: req.gitRef,
+          nodeCount: graph.nodes?.length ?? 0
+        };
+      } catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : "invalid graph", code: "bad_graph" };
+      }
+    }
+    case "query-graph": {
+      const resolved = ctx.registry.resolveGraph(req.repositoryId, req.gitRef);
+      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 });
+      return {
+        ok: true,
+        query: req.query,
+        repositoryId: req.repositoryId,
+        gitRef: resolved.gitRef,
+        matches: result.matches.slice(0, req.limit ?? 12).map((m) => ({
+          id: m.node.id,
+          qualifiedName: m.node.qualifiedName,
+          kind: m.node.kind,
+          file: m.node.file,
+          line: m.node.span?.start ?? 0,
+          score: m.score,
+          why: m.why
+        })),
+        tokensEstimate: result.tokensEstimate
+      };
+    }
+    case "impact-of": {
+      const resolved = ctx.registry.resolveGraph(req.repositoryId, req.gitRef);
+      if (!resolved) {
+        return { ok: false, error: "no ActiveGraph loaded for repository \u2014 put-graph first", code: "no_graph" };
+      }
+      const node = resolveSymbol(resolved.graph, req.symbol);
+      if (!node) {
+        return { ok: false, error: `symbol not found: ${req.symbol}`, code: "not_found" };
+      }
+      const impact = impactOf(resolved.graph, node.id, { depth: req.depth ?? 4 });
+      return {
+        ok: true,
+        repositoryId: req.repositoryId,
+        gitRef: resolved.gitRef,
+        symbol: req.symbol,
+        root: impact.root,
+        depth: impact.depth,
+        affected: impact.affected.slice(0, 40).map((a) => ({
+          id: a.id,
+          name: a.name,
+          kind: a.kind,
+          file: a.file,
+          line: a.line,
+          depth: a.depth,
+          confidence: a.confidence
+        })),
+        direct: impact.direct,
+        transitive: impact.transitive
+      };
+    }
+    case "graph-summary": {
+      const resolved = ctx.registry.resolveGraph(req.repositoryId, req.gitRef);
+      if (!resolved) {
+        return { ok: false, error: "no ActiveGraph loaded for repository \u2014 put-graph first", code: "no_graph" };
+      }
+      const g = resolved.graph;
+      return {
+        ok: true,
+        repositoryId: req.repositoryId,
+        gitRef: resolved.gitRef,
+        summary: {
+          nodeCount: g.nodes?.length ?? 0,
+          edgeCount: g.edges?.length ?? 0,
+          languages: g.meta?.languages ?? [],
+          corpusHash: g.provenance?.corpusHash ?? null,
+          root: g.meta?.root ?? null
+        }
+      };
+    }
+  }
+}
+function resolveSymbol(graph, symbol) {
+  if (graph.nodes.some((n) => n.id === symbol)) return { id: symbol };
+  const hit = resolveOne(graph, symbol);
+  if (hit.node?.id) return { id: hit.node.id };
+  if (hit.candidates.length === 1 && hit.candidates[0]?.id) return { id: hit.candidates[0].id };
+  const q = symbol.toLowerCase();
+  const byQn = graph.nodes.find((n) => n.qualifiedName?.toLowerCase() === q || n.name?.toLowerCase() === q);
+  return byQn ? { id: byQn.id } : null;
+}
+
+// src/runtime/branch-graph-session.ts
+var BranchGraphSession = class {
+  root;
+  repositoryId;
+  cache;
+  graphPath;
+  detectGit;
+  load;
+  gitRun;
+  lastRef = "";
+  constructor(options) {
+    this.root = options.root;
+    this.repositoryId = repositoryIdFromRoot(options.root);
+    this.cache = options.cache ?? new ActiveGraphCache();
+    this.graphPath = options.graphPath;
+    this.detectGit = options.detectGit ?? detectGitRef;
+    this.load = options.load ?? loadGraph;
+    this.gitRun = options.gitRun;
+  }
+  /**
+   * Resolve HEAD, activate the matching cache slot (or load from disk), and
+   * run idle eviction. Returns null graph when no map exists for this ref.
+   */
+  ensureCurrent() {
+    this.cache.evictIdle();
+    const info = this.gitRun ? this.detectGit(this.root, this.gitRun) : this.detectGit(this.root);
+    const gitRef = info.ref || "unknown";
+    const switched = this.lastRef !== "" && this.lastRef !== gitRef;
+    this.lastRef = gitRef;
+    if (this.graphPath) {
+      const graph2 = this.load(this.root, this.graphPath);
+      if (graph2) {
+        this.cache.put(this.repositoryId, gitRef, graph2);
+        this.cache.select(this.repositoryId, gitRef);
+      }
+      return {
+        graph: graph2,
+        gitRef,
+        kind: info.kind,
+        switched,
+        fromCache: false,
+        repositoryId: this.repositoryId
+      };
+    }
+    const warm = this.cache.get(this.repositoryId, gitRef);
+    if (warm) {
+      this.cache.select(this.repositoryId, gitRef);
+      return {
+        graph: warm.graph,
+        gitRef,
+        kind: info.kind,
+        switched,
+        fromCache: true,
+        repositoryId: this.repositoryId
+      };
+    }
+    const graph = this.load(this.root);
+    if (graph) {
+      this.cache.put(this.repositoryId, gitRef, graph);
+      this.cache.select(this.repositoryId, gitRef);
+    }
+    return {
+      graph,
+      gitRef,
+      kind: info.kind,
+      switched,
+      fromCache: false,
+      repositoryId: this.repositoryId
+    };
+  }
+  /** Diagnostics for daemon status / tests. */
+  listSlots() {
+    return this.cache.list(this.repositoryId);
+  }
+};
+
+export { ActiveGraphCache, BranchGraphSession, DEFAULT_ACTIVE_GRAPH_IDLE_MS, VGD_PROTOCOL_VERSION, WorkspaceRegistry, parseRequest, startVgdServer };
+//# sourceMappingURL=chunk-SZLF66FJ.js.map
+//# sourceMappingURL=chunk-SZLF66FJ.js.map