@deeplake/hivemind 0.7.75 → 0.7.77

package/codex/bundle/pre-tool-use.js

@@ -54,13 +54,13 @@ var init_index_marker_store = __esm({
 
 // dist/src/utils/stdin.js
 function readStdin() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
     process.stdin.on("end", () => {
       try {
-        resolve3(JSON.parse(data));
+        resolve4(JSON.parse(data));
       } catch (err) {
         reject(new Error(`Failed to parse hook input: ${err}`));
       }
@@ -522,7 +522,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -552,7 +552,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve3) => this.waiting.push(resolve3));
+    await new Promise((resolve4) => this.waiting.push(resolve4));
   }
   release() {
     this.active--;
@@ -1710,7 +1710,7 @@ var EmbedClient = class {
     }
   }
   connectOnce() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const sock = connect(this.socketPath);
       const to = setTimeout(() => {
         sock.destroy();
@@ -1718,7 +1718,7 @@ var EmbedClient = class {
       }, this.timeoutMs);
       sock.once("connect", () => {
         clearTimeout(to);
-        resolve3(sock);
+        resolve4(sock);
       });
       sock.once("error", (e) => {
         clearTimeout(to);
@@ -1800,7 +1800,7 @@ var EmbedClient = class {
     throw new Error("daemon did not become ready within spawnWaitMs");
   }
   sendAndWait(sock, req) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       let buf = "";
       const to = setTimeout(() => {
         sock.destroy();
@@ -1815,7 +1815,7 @@ var EmbedClient = class {
         const line = buf.slice(0, nl);
         clearTimeout(to);
         try {
-          resolve3(JSON.parse(line));
+          resolve4(JSON.parse(line));
         } catch (e) {
           reject(e);
         }
@@ -2317,6 +2317,1217 @@ async function handleGrepDirect(api, table, sessionsTable, params) {
   return capOutputForClaude(joined, { kind: "grep" });
 }
 
+// dist/src/graph/vfs-handler.js
+import { existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { join as join13, dirname as dirname6 } from "node:path";
+
+// dist/src/graph/last-build.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join10 } from "node:path";
+function lastBuildPath(baseDir, worktreeId) {
+  if (worktreeId !== void 0) {
+    return join10(baseDir, "worktrees", worktreeId, ".last-build.json");
+  }
+  return join10(baseDir, ".last-build.json");
+}
+function readLastBuild(baseDir, worktreeId) {
+  let path = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync5(path)) {
+    if (worktreeId === void 0)
+      return null;
+    const legacy = lastBuildPath(baseDir, void 0);
+    if (!existsSync5(legacy))
+      return null;
+    path = legacy;
+  }
+  let raw;
+  try {
+    raw = readFileSync7(path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object")
+    return null;
+  const o = parsed;
+  if (typeof o.ts !== "number" || !Number.isFinite(o.ts))
+    return null;
+  if (o.commit_sha !== null && typeof o.commit_sha !== "string")
+    return null;
+  if (typeof o.snapshot_sha256 !== "string")
+    return null;
+  const out = { ts: o.ts, commit_sha: o.commit_sha, snapshot_sha256: o.snapshot_sha256 };
+  if (typeof o.node_count === "number" && Number.isFinite(o.node_count) && o.node_count >= 0) {
+    out.node_count = o.node_count;
+  }
+  if (typeof o.edge_count === "number" && Number.isFinite(o.edge_count) && o.edge_count >= 0) {
+    out.edge_count = o.edge_count;
+  }
+  return out;
+}
+
+// dist/src/graph/snapshot.js
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync7, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname5, join as join12 } from "node:path";
+
+// dist/src/graph/history.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname4, join as join11 } from "node:path";
+
+// dist/src/graph/resolve/cross-file.js
+import { posix } from "node:path";
+
+// dist/src/graph/snapshot.js
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join12(homedir8(), ".hivemind", "graphs");
+}
+function repoDir(repoKey) {
+  return join12(graphsRoot(), repoKey);
+}
+
+// dist/src/utils/repo-identity.js
+import { execSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { basename, resolve as resolve2 } from "node:path";
+var DEFAULT_PORTS = {
+  http: "80",
+  https: "443",
+  ssh: "22",
+  git: "9418"
+};
+function normalizeGitRemoteUrl(url) {
+  let s = url.trim();
+  const schemeMatch = s.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
+  if (schemeMatch)
+    s = s.slice(schemeMatch[0].length);
+  if (!scheme) {
+    const scp = s.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      s = `${scp[1]}/${scp[2]}`;
+  }
+  s = s.replace(/^[^@/]+@/, "");
+  if (scheme && DEFAULT_PORTS[scheme]) {
+    s = s.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
+  }
+  s = s.replace(/\.git\/?$/i, "");
+  s = s.replace(/\/+$/, "");
+  return s.toLowerCase();
+}
+function deriveProjectKey(cwd) {
+  const absCwd = resolve2(cwd);
+  const project = basename(absCwd) || "unknown";
+  let signature = null;
+  try {
+    const raw = execSync("git config --get remote.origin.url", {
+      cwd: absCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? absCwd;
+  const key = createHash2("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/graph/render/neighborhood.js
+var CAP = 25;
+function renderNeighborhood(snap, file) {
+  const allFiles = [...new Set(snap.nodes.map((n) => n.source_file))];
+  let resolved = null;
+  if (allFiles.includes(file)) {
+    resolved = file;
+  } else {
+    const matches = allFiles.filter((f) => f.endsWith(file) || f.includes(file));
+    if (matches.length === 1) {
+      resolved = matches[0];
+    } else if (matches.length > 1) {
+      const lines2 = [];
+      lines2.push(`"${file}" matches multiple files \u2014 which did you mean?`);
+      lines2.push("");
+      for (const m of matches.slice(0, 10))
+        lines2.push(`  ${m}`);
+      if (matches.length > 10)
+        lines2.push(`  ... and ${matches.length - 10} more`);
+      return lines2.join("\n");
+    }
+  }
+  if (resolved === null) {
+    const lines2 = [];
+    lines2.push(`No nodes for "${file}".`);
+    const parts = file.split("/").filter((p) => p.length > 2);
+    const close = allFiles.filter((f) => parts.some((p) => f.includes(p))).slice(0, 3);
+    if (close.length > 0) {
+      lines2.push("Did you mean:");
+      for (const c of close)
+        lines2.push(`  ${c}`);
+    }
+    return lines2.join("\n");
+  }
+  const fileNodes = snap.nodes.filter((n) => n.source_file === resolved);
+  const fileNodeIds = new Set(fileNodes.map((n) => n.id));
+  const fileOf = /* @__PURE__ */ new Map();
+  for (const n of snap.nodes)
+    fileOf.set(n.id, n.source_file);
+  const sorted = [...fileNodes].sort((a, b) => {
+    const la = parseLocation(a.source_location);
+    const lb = parseLocation(b.source_location);
+    if (la !== lb)
+      return la - lb;
+    return a.label.localeCompare(b.label);
+  });
+  const lines = [];
+  lines.push(`## Symbols in ${resolved}`);
+  lines.push("");
+  if (sorted.length === 0) {
+    lines.push("  (no symbols)");
+  } else {
+    for (const n of sorted) {
+      const exp = n.exported ? "exported" : "internal";
+      lines.push(`  ${n.label.padEnd(32)} ${n.kind.padEnd(12)} ${exp.padEnd(10)} ${n.source_location}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Cross-file neighbors");
+  lines.push("");
+  lines.push("Note: 'calls' edges are intra-file only in the current extractor \u2014 cross-file");
+  lines.push("neighbors here are driven mainly by 'imports' edges.");
+  lines.push("");
+  const outgoing = [];
+  const incoming = [];
+  for (const e of snap.links) {
+    const srcIn = fileNodeIds.has(e.source);
+    const tgtIn = fileNodeIds.has(e.target);
+    if (srcIn === tgtIn)
+      continue;
+    if (srcIn) {
+      const tgtFile = fileOf.get(e.target);
+      if (tgtFile !== void 0 && tgtFile !== resolved)
+        outgoing.push(e);
+    } else {
+      const srcFile = fileOf.get(e.source);
+      if (srcFile !== void 0 && srcFile !== resolved)
+        incoming.push(e);
+    }
+  }
+  renderDirectionGroup(lines, outgoing, "Outgoing", "source");
+  renderDirectionGroup(lines, incoming, "Incoming", "target");
+  return lines.join("\n");
+}
+function renderDirectionGroup(lines, edges, label, selfField) {
+  const otherField = selfField === "source" ? "target" : "source";
+  const byRelation = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const otherId = e[otherField];
+    const rel = e.relation;
+    let nodeMap = byRelation.get(rel);
+    if (!nodeMap) {
+      nodeMap = /* @__PURE__ */ new Map();
+      byRelation.set(rel, nodeMap);
+    }
+    nodeMap.set(otherId, (nodeMap.get(otherId) ?? 0) + 1);
+  }
+  if (byRelation.size === 0) {
+    lines.push(`${label}: (none)`);
+    lines.push("");
+    return;
+  }
+  lines.push(`${label}:`);
+  let totalShown = 0;
+  const sortedRels = [...byRelation.entries()].sort(([a], [b]) => a.localeCompare(b));
+  for (const [rel, nodeMap] of sortedRels) {
+    const entries = [...nodeMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+    lines.push(`  ${rel} (${entries.length}):`);
+    let shownInRel = 0;
+    for (const [otherId, cnt] of entries) {
+      if (totalShown >= CAP)
+        break;
+      const suffix = cnt > 1 ? ` \xD7${cnt}` : "";
+      lines.push(`    ${otherId}${suffix}`);
+      shownInRel++;
+      totalShown++;
+    }
+    const remaining = entries.length - shownInRel;
+    if (remaining > 0)
+      lines.push(`    ... and ${remaining} more`);
+  }
+  if (totalShown >= CAP) {
+    const total = [...byRelation.values()].reduce((s, m) => s + m.size, 0);
+    if (total > CAP)
+      lines.push(`  ... and ${total - CAP} more`);
+  }
+  lines.push("");
+}
+function parseLocation(loc) {
+  const m = loc.match(/^L(\d+)/);
+  return m ? parseInt(m[1], 10) : 0;
+}
+
+// dist/src/graph/render/layers.js
+var LAYER_RULES = [
+  { layer: "Tests", test: (p) => p.includes("/tests/") || p.includes(".test.") || p.includes("/__tests__/") },
+  { layer: "Hooks", test: (p) => p.includes("/hooks/") },
+  { layer: "CLI", test: (p) => p.includes("/cli/") || p.includes("/commands/") },
+  { layer: "Graph", test: (p) => p.includes("/graph/") },
+  { layer: "Shell/VFS", test: (p) => p.includes("/shell/") },
+  { layer: "Embeddings", test: (p) => p.includes("/embeddings/") },
+  { layer: "Skillify", test: (p) => p.includes("/skillify/") },
+  { layer: "Config", test: (p) => /(?:^|\/)config\.[^/]+$/.test(p) || /\.config\.[^/]+$/.test(p) },
+  { layer: "Utils", test: (p) => p.includes("/utils/") }
+];
+function layerOf(sourceFile) {
+  const p = sourceFile.startsWith("/") ? sourceFile : `/${sourceFile}`;
+  for (const rule of LAYER_RULES) {
+    if (rule.test(p))
+      return rule.layer;
+  }
+  return "Core";
+}
+function renderLayers(snap) {
+  try {
+    const layerNodes = /* @__PURE__ */ new Map();
+    const layerFiles = /* @__PURE__ */ new Map();
+    for (const node of snap.nodes) {
+      const layer = layerOf(node.source_file);
+      layerNodes.set(layer, (layerNodes.get(layer) ?? 0) + 1);
+      let fileMap = layerFiles.get(layer);
+      if (!fileMap) {
+        fileMap = /* @__PURE__ */ new Map();
+        layerFiles.set(layer, fileMap);
+      }
+      fileMap.set(node.source_file, (fileMap.get(node.source_file) ?? 0) + 1);
+    }
+    if (layerNodes.size === 0) {
+      return "No nodes in snapshot \u2014 nothing to layer.";
+    }
+    const sorted = [...layerNodes.entries()].sort(([, a], [, b]) => b - a);
+    const lines = [];
+    lines.push("## Architectural Layers");
+    lines.push("");
+    for (const [layer, count] of sorted) {
+      lines.push(`${layer.padEnd(14)} ${String(count).padStart(4)} node${count === 1 ? "" : "s"}`);
+      const fileMap = layerFiles.get(layer);
+      const topFiles = [...fileMap.entries()].sort(([, a], [, b]) => b - a).slice(0, 5);
+      for (const [file, n] of topFiles) {
+        lines.push(`  ${String(n).padStart(3)}  ${file}`);
+      }
+      if (fileMap.size > 5) {
+        lines.push(`       ... and ${fileMap.size - 5} more file${fileMap.size - 5 === 1 ? "" : "s"}`);
+      }
+    }
+    lines.push("");
+    lines.push(`Total: ${snap.nodes.length} node${snap.nodes.length === 1 ? "" : "s"} across ${sorted.length} layer${sorted.length === 1 ? "" : "s"}`);
+    return lines.join("\n");
+  } catch {
+    return "Failed to render layer view.";
+  }
+}
+
+// dist/src/graph/render/tour.js
+var LINE_CAP = 60;
+function renderTour(snap) {
+  if (snap.nodes.length === 0) {
+    return "Graph is empty \u2014 no nodes to tour.";
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of snap.nodes)
+    nodeMap.set(n.id, n);
+  const inDegOrig = /* @__PURE__ */ new Map();
+  for (const n of snap.nodes)
+    inDegOrig.set(n.id, 0);
+  for (const e of snap.links) {
+    if (nodeMap.has(e.source) && nodeMap.has(e.target)) {
+      inDegOrig.set(e.target, (inDegOrig.get(e.target) ?? 0) + 1);
+    }
+  }
+  const entryPoints = snap.nodes.filter((n) => n.exported && inDegOrig.get(n.id) === 0).sort((a, b) => a.id.localeCompare(b.id));
+  const entrySet = new Set(entryPoints.map((n) => n.id));
+  const revAdj = /* @__PURE__ */ new Map();
+  const inDegRev = /* @__PURE__ */ new Map();
+  for (const n of snap.nodes) {
+    revAdj.set(n.id, []);
+    inDegRev.set(n.id, 0);
+  }
+  for (const e of snap.links) {
+    if (!nodeMap.has(e.source) || !nodeMap.has(e.target))
+      continue;
+    revAdj.get(e.target).push(e.source);
+    inDegRev.set(e.source, (inDegRev.get(e.source) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const n of snap.nodes) {
+    if (inDegRev.get(n.id) === 0)
+      queue.push(n.id);
+  }
+  queue.sort();
+  const topoOrder = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    topoOrder.push(id);
+    const newReady = [];
+    for (const dep of revAdj.get(id) ?? []) {
+      const d = (inDegRev.get(dep) ?? 0) - 1;
+      inDegRev.set(dep, d);
+      if (d === 0)
+        newReady.push(dep);
+    }
+    if (newReady.length > 0) {
+      for (const x of newReady)
+        queue.push(x);
+      queue.sort();
+    }
+  }
+  const topoSet = new Set(topoOrder);
+  const cyclic = snap.nodes.filter((n) => !topoSet.has(n.id)).sort((a, b) => a.id.localeCompare(b.id));
+  const walkthrough = topoOrder.filter((id) => !entrySet.has(id));
+  const totalNodes = snap.nodes.length;
+  const lines = [];
+  lines.push(`# Code Graph Tour \u2014 ${totalNodes} node${totalNodes !== 1 ? "s" : ""}`);
+  lines.push("");
+  lines.push(`## Entry points (${entryPoints.length})`);
+  if (entryPoints.length === 0) {
+    lines.push("  (none \u2014 all exported nodes have at least one incoming edge)");
+  } else {
+    lines.push("  Exported symbols with no incoming edges \u2014 likely top-level public API.");
+    lines.push("");
+    for (let i = 0; i < entryPoints.length; i++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${entryPoints.length - i} more`);
+        break;
+      }
+      lines.push(`  ${i + 1}. ${entryPoints[i].id}  [${entryPoints[i].kind}]`);
+    }
+  }
+  lines.push("");
+  lines.push(`## Walkthrough \u2014 dependency order (${walkthrough.length})`);
+  if (walkthrough.length === 0) {
+    lines.push("  (all non-entry nodes are cyclic)");
+  } else {
+    lines.push("  Dependencies before dependents (bottom-up).");
+    lines.push("");
+    for (let i = 0; i < walkthrough.length; i++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${walkthrough.length - i} more`);
+        break;
+      }
+      const n = nodeMap.get(walkthrough[i]);
+      lines.push(`  ${i + 1}. ${n.id}  [${n.kind}]`);
+    }
+  }
+  lines.push("");
+  if (cyclic.length > 0) {
+    lines.push(`## Cyclic / remaining (${cyclic.length})`);
+    lines.push("  These nodes form cycles and were not reached by topological sort.");
+    lines.push("");
+    for (let i = 0; i < cyclic.length; i++) {
+      if (lines.length >= LINE_CAP) {
+        lines.push(`  ... and ${cyclic.length - i} more`);
+        break;
+      }
+      lines.push(`  ${i + 1}. ${cyclic[i].id}  [${cyclic[i].kind}]`);
+    }
+    lines.push("");
+  }
+  lines.push(`Total: ${entryPoints.length} entry + ${walkthrough.length} walkthrough` + (cyclic.length > 0 ? ` + ${cyclic.length} cyclic` : "") + ` = ${totalNodes} nodes`);
+  return lines.join("\n");
+}
+
+// dist/src/graph/render/path.js
+function resolvePattern(snap, pattern) {
+  const needle = pattern.toLowerCase();
+  return snap.nodes.filter((n) => n.id.toLowerCase().includes(needle) || n.label.toLowerCase().includes(needle)).map((n) => n.id).sort();
+}
+function buildAdjacency(snap, undirected) {
+  const adj = /* @__PURE__ */ new Map();
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const n of snap.nodes) {
+    adj.set(n.id, []);
+    nodeIds.add(n.id);
+  }
+  for (const edge of snap.links) {
+    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target))
+      continue;
+    adj.get(edge.source).push({ neighborId: edge.target, edge, reversed: false });
+    if (undirected) {
+      adj.get(edge.target).push({ neighborId: edge.source, edge, reversed: true });
+    }
+  }
+  for (const neighbors of adj.values()) {
+    neighbors.sort((a, b) => a.neighborId.localeCompare(b.neighborId) || a.edge.relation.localeCompare(b.edge.relation) || (a.reversed === b.reversed ? 0 : a.reversed ? 1 : -1));
+  }
+  return adj;
+}
+function bfs(adj, fromId, toId) {
+  if (fromId === toId)
+    return [];
+  const parent = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  const queue = [fromId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const { neighborId, edge, reversed } of adj.get(current) ?? []) {
+      if (visited.has(neighborId))
+        continue;
+      visited.add(neighborId);
+      parent.set(neighborId, { parentId: current, hop: { edge, reversed } });
+      if (neighborId === toId) {
+        const hops = [];
+        let cur = toId;
+        while (cur !== fromId) {
+          const p = parent.get(cur);
+          hops.unshift(p.hop);
+          cur = p.parentId;
+        }
+        return hops;
+      }
+      queue.push(neighborId);
+    }
+  }
+  return null;
+}
+function renderHops(fromId, hops, undirected) {
+  const lines = [];
+  lines.push(`${undirected ? "Undirected path" : "Directed path"}  (${hops.length} hop${hops.length === 1 ? "" : "s"}):`);
+  lines.push("");
+  lines.push(`  ${fromId}`);
+  for (const { edge, reversed } of hops) {
+    if (reversed) {
+      lines.push(`    <--${edge.relation}--  ${edge.source}  [real edge: ${edge.source} \u2192 ${edge.target}]`);
+    } else {
+      lines.push(`    --${edge.relation}-->  ${edge.target}`);
+    }
+  }
+  if (undirected) {
+    lines.push("");
+    lines.push("Note: no directed path exists. Arrows with <-- are traversed against their declared direction.");
+  }
+  return lines.join("\n");
+}
+function candidateList(pattern, ids) {
+  const lines = [`"${pattern}" matches ${ids.length} nodes \u2014 be more specific:`];
+  lines.push("");
+  const shown = ids.slice(0, 20);
+  for (let i = 0; i < shown.length; i++)
+    lines.push(`  [${i + 1}]  ${shown[i]}`);
+  if (ids.length > 20)
+    lines.push(`  ... and ${ids.length - 20} more`);
+  return lines.join("\n");
+}
+function renderPath(snap, fromPattern, toPattern) {
+  const fromIds = resolvePattern(snap, fromPattern);
+  const toIds = resolvePattern(snap, toPattern);
+  if (fromIds.length === 0) {
+    return `No node matches "${fromPattern}". Try cat memory/graph/find/<pattern> to explore.`;
+  }
+  if (toIds.length === 0) {
+    return `No node matches "${toPattern}". Try cat memory/graph/find/<pattern> to explore.`;
+  }
+  if (fromIds.length > 1)
+    return candidateList(fromPattern, fromIds);
+  if (toIds.length > 1)
+    return candidateList(toPattern, toIds);
+  const fromId = fromIds[0];
+  const toId = toIds[0];
+  if (fromId === toId) {
+    return `"${fromId}" is the same node on both ends \u2014 path length 0.`;
+  }
+  const dirPath = bfs(buildAdjacency(snap, false), fromId, toId);
+  if (dirPath !== null)
+    return renderHops(fromId, dirPath, false);
+  const undirPath = bfs(buildAdjacency(snap, true), fromId, toId);
+  if (undirPath !== null)
+    return renderHops(fromId, undirPath, true);
+  const fromNode = snap.nodes.find((n) => n.id === fromId);
+  const toNode = snap.nodes.find((n) => n.id === toId);
+  const sameFile = fromNode && toNode && fromNode.source_file === toNode.source_file;
+  const context = sameFile ? `Both are in ${fromNode.source_file} \u2014 same file but no connecting edges.` : `Sources: ${fromNode?.source_file ?? "?"} vs ${toNode?.source_file ?? "?"} \u2014 they appear disconnected.`;
+  return [`No path found between:`, `  from: ${fromId}`, `  to:   ${toId}`, ``, context].join("\n");
+}
+
+// dist/src/graph/render/impact.js
+var IMPACT_CAP = 80;
+var MAX_DEPTH = 25;
+function renderImpact(snap, pattern) {
+  const needle = pattern.toLowerCase();
+  const matches = snap.nodes.filter((n) => n.id.toLowerCase().includes(needle));
+  if (matches.length === 0) {
+    return `No node matches "${pattern}". Try cat memory/graph/find/${pattern} to explore.`;
+  }
+  if (matches.length > 1) {
+    const lines2 = [`"${pattern}" matches ${matches.length} nodes \u2014 be more specific:`, ""];
+    for (const m of matches.slice(0, 20))
+      lines2.push(`  ${m.id}`);
+    if (matches.length > 20)
+      lines2.push(`  ... and ${matches.length - 20} more`);
+    return lines2.join("\n");
+  }
+  const target = matches[0];
+  const nodeIds = new Set(snap.nodes.map((n) => n.id));
+  const incoming = /* @__PURE__ */ new Map();
+  for (const e of snap.links) {
+    if (!nodeIds.has(e.source))
+      continue;
+    const list = incoming.get(e.target);
+    if (list)
+      list.push(e);
+    else
+      incoming.set(e.target, [e]);
+  }
+  const depthOf = /* @__PURE__ */ new Map();
+  const viaOf = /* @__PURE__ */ new Map();
+  depthOf.set(target.id, 0);
+  let frontier = [target.id];
+  let depth = 0;
+  while (frontier.length > 0 && depth < MAX_DEPTH) {
+    depth++;
+    const next = [];
+    for (const id of frontier) {
+      const edges = (incoming.get(id) ?? []).slice().sort((a, b) => a.source.localeCompare(b.source) || a.relation.localeCompare(b.relation));
+      for (const e of edges) {
+        if (depthOf.has(e.source))
+          continue;
+        depthOf.set(e.source, depth);
+        viaOf.set(e.source, { rel: e.relation, from: id });
+        next.push(e.source);
+      }
+    }
+    next.sort();
+    frontier = next;
+  }
+  const dependents = [...depthOf.entries()].filter(([id]) => id !== target.id);
+  const total = dependents.length;
+  const lines = [];
+  lines.push(`Impact of ${target.id}`);
+  if (target.signature)
+    lines.push(`  ${target.signature}`);
+  lines.push("");
+  if (total === 0) {
+    lines.push("No resolved dependents \u2014 nothing in the graph reaches this symbol.");
+    lines.push("(Cross-file resolution is partial; this is a lower bound, not proof it's unused.)");
+    return lines.join("\n");
+  }
+  lines.push(`${total} dependent${total === 1 ? "" : "s"} (transitive), by depth:`);
+  lines.push("");
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const [id, d] of dependents) {
+    const list = byDepth.get(d) ?? [];
+    list.push(id);
+    byDepth.set(d, list);
+  }
+  let shown = 0;
+  for (const d of [...byDepth.keys()].sort((a, b) => a - b)) {
+    const ids = byDepth.get(d).sort();
+    lines.push(`  depth ${d} (${ids.length}):`);
+    for (const id of ids) {
+      if (shown >= IMPACT_CAP)
+        break;
+      const via = viaOf.get(id);
+      const tag = via ? `  [${via.rel} \u2192 ${via.from}]` : "";
+      lines.push(`    ${id}${tag}`);
+      shown++;
+    }
+    if (shown >= IMPACT_CAP)
+      break;
+  }
+  if (total > shown)
+    lines.push(`  ... and ${total - shown} more`);
+  lines.push("");
+  lines.push("Note: only RESOLVED edges are traversed (cross-file resolution is partial),");
+  lines.push("so this is a lower bound on impact, not a completeness guarantee.");
+  return lines.join("\n");
+}
+
+// dist/src/graph/vfs-handler.js
+function workTreeIdFor(cwd) {
+  return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function handleGraphVfs(subpath, cwd) {
+  const path = subpath.replace(/^\/+/, "");
+  if (path === "" || path === "/") {
+    return { kind: "ok", body: dirListing() };
+  }
+  if (path === "index.md" || path === "index") {
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderIndex(snap, baseDir, cwd)
+    }));
+  }
+  if (path.startsWith("find/")) {
+    const pattern = path.slice("find/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "find/ requires a pattern: cat memory/graph/find/<keyword>" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderFind(snap, pattern, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path.startsWith("show/")) {
+    const key = path.slice("show/".length);
+    if (key === "") {
+      return { kind: "not-found", message: "show/ requires a handle or pattern" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path.startsWith("query/")) {
+    const pattern = path.slice("query/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "query/ requires a pattern: cat memory/graph/query/<keyword>" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderQuery(snap, pattern, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path.startsWith("impact/")) {
+    const pattern = path.slice("impact/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "impact/ requires a pattern: cat memory/graph/impact/<symbol>" };
+    }
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderImpact(snap, pattern) }));
+  }
+  if (path.startsWith("neighborhood/")) {
+    const file = path.slice("neighborhood/".length);
+    if (file === "") {
+      return { kind: "not-found", message: "neighborhood/ requires a file path: cat memory/graph/neighborhood/<file>" };
+    }
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderNeighborhood(snap, file) }));
+  }
+  if (path === "layers" || path === "layers/" || path === "layers/index.md") {
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderLayers(snap) }));
+  }
+  if (path === "tour" || path === "tour/" || path === "tour/index.md") {
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderTour(snap) }));
+  }
+  if (path.startsWith("path/")) {
+    const rest = path.slice("path/".length);
+    const slash = rest.indexOf("/");
+    if (slash <= 0 || slash === rest.length - 1) {
+      return { kind: "not-found", message: "path/ needs two patterns: cat memory/graph/path/<from>/<to> (each a symbol-name substring, no slash)" };
+    }
+    const fromPattern = rest.slice(0, slash);
+    const toPattern = rest.slice(slash + 1);
+    return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderPath(snap, fromPattern, toPattern) }));
+  }
+  return {
+    kind: "not-found",
+    message: `Unknown endpoint: graph/${path}
+Available: index.md, find/<pattern>, query/<pattern>, show/<handle-or-pattern>, impact/<pattern>, neighborhood/<file>, layers, tour, path/<from>/<to>`
+  };
+}
+function loadSnapshotOrError(cwd, fn) {
+  let key;
+  let baseDir;
+  try {
+    key = deriveProjectKey(cwd).key;
+    baseDir = repoDir(key);
+  } catch (e) {
+    return { kind: "no-graph", message: `Cannot derive repo identity: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  const wt = workTreeIdFor(cwd);
+  const last = readLastBuild(baseDir, wt);
+  if (last === null) {
+    return {
+      kind: "no-graph",
+      message: "No local graph for this worktree yet. Run `hivemind graph build` (or `hivemind graph pull` if a teammate has built this commit)."
+    };
+  }
+  const fileBase = last.commit_sha ?? last.snapshot_sha256;
+  const snapPath = join13(baseDir, "snapshots", `${fileBase}.json`);
+  if (!existsSync7(snapPath)) {
+    return { kind: "no-graph", message: `Snapshot file missing on disk: ${snapPath}` };
+  }
+  let snap;
+  try {
+    snap = JSON.parse(readFileSync9(snapPath, "utf8"));
+  } catch (e) {
+    return { kind: "no-graph", message: `Failed to parse snapshot: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!Array.isArray(snap.nodes) || !Array.isArray(snap.links)) {
+    return { kind: "no-graph", message: "Snapshot schema is invalid (missing nodes/links arrays)." };
+  }
+  try {
+    return fn(snap, baseDir);
+  } catch (e) {
+    return { kind: "no-graph", message: `Failed to render graph view: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+function dirListing() {
+  return [
+    "index.md",
+    "find/",
+    "query/",
+    "show/",
+    "impact/",
+    "neighborhood/",
+    "layers",
+    "tour",
+    "path/"
+  ].join("\n");
+}
+function renderIndex(snap, baseDir, cwd) {
+  const commit = snap.graph.commit_sha?.slice(0, 7) ?? "no-commit";
+  const fullCommit = snap.graph.commit_sha ?? "no-commit";
+  const totalNodes = snap.nodes.length;
+  const totalEdges = snap.links.length;
+  const byFile = {};
+  for (const n of snap.nodes)
+    byFile[n.source_file] = (byFile[n.source_file] ?? 0) + 1;
+  const topFiles = Object.entries(byFile).sort(([, a], [, b]) => b - a).slice(0, 8);
+  const byRel = {};
+  for (const e of snap.links)
+    byRel[e.relation] = (byRel[e.relation] ?? 0) + 1;
+  const byKind = {};
+  for (const n of snap.nodes)
+    byKind[n.kind] = (byKind[n.kind] ?? 0) + 1;
+  const lines = [];
+  lines.push(`# Code Graph \u2014 ${snap.observation.repo_project}`);
+  lines.push("");
+  lines.push(`Commit:  ${fullCommit}  (built ${snap.observation.ts})`);
+  lines.push(`Branch:  ${snap.observation.branch ?? "(detached)"}`);
+  lines.push(`Source:  ${join13(baseDir, "snapshots", `${commit ? snap.graph.commit_sha : "?"}.json`)}`);
+  lines.push("");
+  lines.push(`Nodes:   ${totalNodes}    Edges: ${totalEdges}`);
+  lines.push("");
+  lines.push("## How to query");
+  lines.push("  cat ~/.deeplake/memory/graph/query/<pattern>");
+  lines.push("    2-in-1: search + expand the top matches with their 1-hop");
+  lines.push("    neighbors (callers/callees/imports/heritage). Start here.");
+  lines.push("    Multi-token AND: query/<a>+<b> requires both tokens.");
+  lines.push("");
+  lines.push("  cat ~/.deeplake/memory/graph/find/<pattern>");
+  lines.push("    Case-insensitive substring match on node id + label.");
+  lines.push("    Emits numbered handles [1] [2] ... saved for this worktree.");
+  lines.push("");
+  lines.push("  cat ~/.deeplake/memory/graph/show/<handle-or-pattern>");
+  lines.push("    <handle>: a digit from a prior `find/`/`query/` (e.g. 3).");
+  lines.push("    <pattern>: a substring; resolves to a unique node if possible,");
+  lines.push("               or shows candidates if ambiguous.");
+  lines.push("    Output: node detail + 1-hop neighbors grouped by edge kind.");
+  lines.push("");
+  lines.push("  Also: neighborhood/<file> \xB7 layers \xB7 tour \xB7 path/<from>/<to>");
+  lines.push("");
+  lines.push("## Node kinds");
+  for (const [k, n] of Object.entries(byKind).sort(([, a], [, b]) => b - a)) {
+    lines.push(`  ${k.padEnd(12)} ${n}`);
+  }
+  lines.push("");
+  lines.push("## Edge kinds");
+  for (const [k, n] of Object.entries(byRel).sort(([, a], [, b]) => b - a)) {
+    lines.push(`  ${k.padEnd(12)} ${n}`);
+  }
+  lines.push("");
+  lines.push("## Top files by node count");
+  for (const [f, n] of topFiles) {
+    lines.push(`  ${String(n).padStart(4)}  ${f}`);
+  }
+  lines.push("");
+  lines.push(`Limitations:`);
+  lines.push(`  - TypeScript / JavaScript / Python. AST-based, no semantic similarity edges yet.`);
+  lines.push(`  - Cross-file 'calls'/'imports'/'extends' ARE resolved for relative named/namespace`);
+  lines.push(`    imports; bare (npm)/aliased/barrel/dynamic imports stay unresolved. So a node`);
+  lines.push(`    with "Incoming (0)" is not proof of dead code \u2014 a caller may reach it via an`);
+  lines.push(`    unresolved import path. (Python cross-file resolution is a follow-up; Python is`);
+  lines.push(`    intra-file + structure only for now.)`);
+  lines.push(`  - Stale after edits \u2014 if a file's mtime is newer than the build, read the live source.`);
+  void cwd;
+  return lines.join("\n");
+}
+function findMatches(snap, pattern) {
+  const tokens = pattern.toLowerCase().split(/[\s+]+/).filter((t) => t.length > 0);
+  if (tokens.length === 0)
+    return [];
+  if (tokens.length === 1) {
+    const needle = tokens[0];
+    const matches2 = [];
+    for (const n of snap.nodes) {
+      if (n.id.toLowerCase().includes(needle) || n.label.toLowerCase().includes(needle))
+        matches2.push(n);
+    }
+    matches2.sort((a, b) => {
+      const ra = rank(a, needle);
+      const rb = rank(b, needle);
+      if (ra !== rb)
+        return ra - rb;
+      return a.id.localeCompare(b.id);
+    });
+    if (matches2.length === 0)
+      return fuzzyMatches(snap, needle);
+    return matches2;
+  }
+  const matches = [];
+  for (const n of snap.nodes) {
+    const id = n.id.toLowerCase();
+    const lbl = n.label.toLowerCase();
+    if (tokens.every((t) => id.includes(t) || lbl.includes(t)))
+      matches.push(n);
+  }
+  const score = (n) => tokens.reduce((s, t) => s + rank(n, t), 0);
+  matches.sort((a, b) => {
+    const sa = score(a);
+    const sb = score(b);
+    if (sa !== sb)
+      return sa - sb;
+    return a.id.localeCompare(b.id);
+  });
+  return matches;
+}
+function fuzzyMatches(snap, needle) {
+  if (needle.length < 3)
+    return [];
+  const maxDist = Math.max(1, Math.floor(needle.length / 4));
+  const scored = [];
+  for (const n of snap.nodes) {
+    const d = editDistance(needle, n.label.toLowerCase(), maxDist);
+    if (d <= maxDist)
+      scored.push({ n, d });
+  }
+  scored.sort((a, b) => a.d !== b.d ? a.d - b.d : a.n.id.localeCompare(b.n.id));
+  return scored.slice(0, 25).map((s) => s.n);
+}
+function editDistance(a, b, cap) {
+  if (Math.abs(a.length - b.length) > cap)
+    return cap + 1;
+  let prev = new Array(b.length + 1);
+  let cur = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++)
+    prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    cur[0] = i;
+    let rowMin = cur[0];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+      if (cur[j] < rowMin)
+        rowMin = cur[j];
+    }
+    if (rowMin > cap)
+      return cap + 1;
+    [prev, cur] = [cur, prev];
+  }
+  return prev[b.length];
+}
+function renderFind(snap, pattern, baseDir, worktreeId) {
+  const matches = findMatches(snap, pattern);
+  const capped = matches.slice(0, 50);
+  if (capped.length === 0) {
+    return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
+Try a shorter or different substring.`;
+  }
+  saveHandles(baseDir, worktreeId, capped.map((n) => n.id), pattern);
+  const lines = [];
+  lines.push(`${matches.length} match${matches.length === 1 ? "" : "es"} for "${pattern}"${matches.length > capped.length ? ` (showing first ${capped.length})` : ""}:`);
+  lines.push("");
+  for (let i = 0; i < capped.length; i++) {
+    const n = capped[i];
+    const tag = n.exported ? "exported" : "internal";
+    lines.push(`  [${i + 1}]  ${n.id}   ${n.kind} (${tag})`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> to see node + 1-hop neighbors");
+  return lines.join("\n");
+}
+var QUERY_TOP_N = 5;
+var QUERY_NEIGHBOR_CAP = 8;
+function renderQuery(snap, pattern, baseDir, worktreeId) {
+  const matches = findMatches(snap, pattern);
+  if (matches.length === 0) {
+    return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
+Try a shorter or different substring, or cat memory/graph/find/<pattern>.`;
+  }
+  const top = matches.slice(0, QUERY_TOP_N);
+  saveHandles(baseDir, worktreeId, top.map((n) => n.id), pattern);
+  const topIds = new Set(top.map((n) => n.id));
+  const outByNode = /* @__PURE__ */ new Map();
+  const inByNode = /* @__PURE__ */ new Map();
+  for (const e of snap.links) {
+    if (topIds.has(e.source))
+      (outByNode.get(e.source) ?? setGet(outByNode, e.source)).push(e);
+    if (topIds.has(e.target))
+      (inByNode.get(e.target) ?? setGet(inByNode, e.target)).push(e);
+  }
+  const lines = [];
+  lines.push(`Query "${pattern}" \u2014 ${matches.length} match${matches.length === 1 ? "" : "es"}, expanded top ${top.length} (1 hop)`);
+  lines.push("");
+  for (let i = 0; i < top.length; i++) {
+    const n = top[i];
+    const tags = [n.exported ? "exported" : "internal"];
+    if (n.is_entrypoint)
+      tags.push("entrypoint");
+    if (n.fan_in !== void 0)
+      tags.push(`fan_in=${n.fan_in}`);
+    if (n.fan_out !== void 0)
+      tags.push(`fan_out=${n.fan_out}`);
+    lines.push(`[${i + 1}] ${n.id}  ${n.kind} (${tags.join(", ")})`);
+    if (n.signature)
+      lines.push(`      ${n.signature}`);
+    renderHopGroup(lines, outByNode.get(n.id) ?? [], "OUT", "target");
+    renderHopGroup(lines, inByNode.get(n.id) ?? [], "IN", "source");
+    lines.push("");
+  }
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> for full detail on a match.");
+  return lines.join("\n");
+}
+function setGet(m, key) {
+  const list = [];
+  m.set(key, list);
+  return list;
+}
+function renderHopGroup(lines, edges, dir, otherField) {
+  if (edges.length === 0)
+    return;
+  const byRel = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    let counts = byRel.get(e.relation);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      byRel.set(e.relation, counts);
+    }
+    const id = e[otherField];
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+  for (const [rel, counts] of [...byRel.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const arrow = dir === "OUT" ? `--${rel}-->` : `<--${rel}--`;
+    const ids = [...counts.keys()].sort();
+    const shown = ids.slice(0, QUERY_NEIGHBOR_CAP).map((id) => {
+      const c = counts.get(id);
+      return c > 1 ? `${id} \xD7${c}` : id;
+    });
+    const more = ids.length > shown.length ? `  (+${ids.length - shown.length} more)` : "";
+    lines.push(`      ${arrow} ${shown.join(", ")}${more}`);
+  }
+}
+function renderShow(snap, key, baseDir, worktreeId) {
+  if (/^\d+$/.test(key)) {
+    const idx = parseInt(key, 10);
+    const handles = loadHandles(baseDir, worktreeId);
+    if (handles === null) {
+      return `Handle [${idx}] not resolvable: no recent find/ in this worktree. Run cat memory/graph/find/<pattern> first.`;
+    }
+    if (idx < 1 || idx > handles.ids.length) {
+      return `Handle [${idx}] out of range. Last find/${handles.pattern} produced ${handles.ids.length} matches.`;
+    }
+    const nodeId = handles.ids[idx - 1];
+    const node = snap.nodes.find((n) => n.id === nodeId);
+    if (!node) {
+      return `Handle [${idx}] points at "${nodeId}" but that node is no longer in the snapshot (graph rebuilt since last find?). Re-run find.`;
+    }
+    return renderNodeDetail(snap, node);
+  }
+  const needle = key.toLowerCase();
+  const matches = snap.nodes.filter((n) => n.id.toLowerCase().includes(needle));
+  if (matches.length === 0) {
+    return `No node matches "${key}". Try cat memory/graph/find/${key} for fuzzy search.`;
+  }
+  if (matches.length === 1) {
+    return renderNodeDetail(snap, matches[0]);
+  }
+  saveHandles(baseDir, worktreeId, matches.slice(0, 50).map((n) => n.id), key);
+  const lines = [];
+  lines.push(`"${key}" matches ${matches.length} nodes. Pick one:`);
+  lines.push("");
+  for (let i = 0; i < Math.min(matches.length, 50); i++) {
+    lines.push(`  [${i + 1}]  ${matches[i].id}`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N>");
+  return lines.join("\n");
+}
+function renderNodeDetail(snap, node) {
+  const incoming = [];
+  const outgoing = [];
+  for (const e of snap.links) {
+    if (e.target === node.id)
+      incoming.push(e);
+    if (e.source === node.id)
+      outgoing.push(e);
+  }
+  const groupBy = (es) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const e of es) {
+      const list = m.get(e.relation) ?? [];
+      list.push(e);
+      m.set(e.relation, list);
+    }
+    return m;
+  };
+  const inGrp = groupBy(incoming);
+  const outGrp = groupBy(outgoing);
+  const lines = [];
+  lines.push(`Node: ${node.id}`);
+  lines.push(`  source: ${node.source_file}:${node.source_location}`);
+  lines.push(`  kind:   ${node.kind}`);
+  lines.push(`  label:  ${node.label}`);
+  if (node.signature)
+    lines.push(`  sig:    ${node.signature}`);
+  if (node.doc)
+    lines.push(`  doc:    ${node.doc}`);
+  const tags = [node.exported ? "exported" : "internal"];
+  if (node.is_entrypoint)
+    tags.push("entrypoint");
+  if (node.fan_in !== void 0)
+    tags.push(`fan_in=${node.fan_in}`);
+  if (node.fan_out !== void 0)
+    tags.push(`fan_out=${node.fan_out}`);
+  lines.push(`  ${tags.join("  ")}`);
+  lines.push("");
+  const inHint = incoming.length === 0 ? "  \u2014 no resolved callers (cross-file resolution is partial; not proof of dead code)" : ":";
+  lines.push(`Incoming (${incoming.length})${inHint}`);
+  for (const [rel, es] of [...inGrp.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`  ${rel} (${es.length}):`);
+    for (const e of es.slice(0, 20)) {
+      lines.push(`    ${e.source}`);
+    }
+    if (es.length > 20)
+      lines.push(`    ... and ${es.length - 20} more`);
+  }
+  lines.push("");
+  lines.push(`Outgoing (${outgoing.length})${outgoing.length === 0 ? "  \u2014 this node has no edges out" : ":"}`);
+  for (const [rel, es] of [...outGrp.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`  ${rel} (${es.length}):`);
+    for (const e of es.slice(0, 20)) {
+      lines.push(`    ${e.target}`);
+    }
+    if (es.length > 20)
+      lines.push(`    ... and ${es.length - 20} more`);
+  }
+  return lines.join("\n");
+}
+function rank(n, needle) {
+  const lbl = n.label.toLowerCase();
+  const id = n.id.toLowerCase();
+  if (lbl === needle)
+    return 0;
+  if (lbl.startsWith(needle))
+    return 1;
+  if (lbl.includes(needle))
+    return 2;
+  if (id.includes(needle))
+    return 3;
+  return 4;
+}
+function handlesPath(baseDir, worktreeId) {
+  return join13(baseDir, "worktrees", worktreeId, ".find-handles.json");
+}
+function saveHandles(baseDir, worktreeId, ids, pattern) {
+  const path = handlesPath(baseDir, worktreeId);
+  const payload = { pattern, ts: Date.now(), ids };
+  try {
+    mkdirSync8(dirname6(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync7(tmp, JSON.stringify(payload));
+    renameSync5(tmp, path);
+  } catch {
+  }
+}
+function loadHandles(baseDir, worktreeId) {
+  const path = handlesPath(baseDir, worktreeId);
+  if (!existsSync7(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object")
+      return null;
+    const o = parsed;
+    if (typeof o.pattern !== "string")
+      return null;
+    if (typeof o.ts !== "number")
+      return null;
+    if (!Array.isArray(o.ids))
+      return null;
+    if (!o.ids.every((s) => typeof s === "string"))
+      return null;
+    return { pattern: o.pattern, ts: o.ts, ids: o.ids };
+  } catch {
+    return null;
+  }
+}
+
+// dist/src/graph/graph-command.js
+var GRAPH_ROOT = "/graph";
+var GRAPH_PREFIX = "/graph/";
+function tokenize(s) {
+  return s.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+}
+function stripQuotes(p) {
+  if (p.length >= 2 && (p[0] === '"' && p[p.length - 1] === '"' || p[0] === "'" && p[p.length - 1] === "'")) {
+    return p.slice(1, -1);
+  }
+  return p;
+}
+function parseReadTargetPath(rewrittenCommand) {
+  const cmd = rewrittenCommand.replace(/\s+2>\S+/g, "").trim();
+  const pipeIdx = cmd.indexOf("|");
+  let readPart = cmd;
+  if (pipeIdx >= 0) {
+    readPart = cmd.slice(0, pipeIdx).trim();
+    const after = cmd.slice(pipeIdx + 1).trim();
+    if (after.includes("|"))
+      return null;
+    if (!/^(?:head|tail)\b/.test(after))
+      return null;
+    if (!/^cat\b/.test(readPart))
+      return null;
+  }
+  const tokens = tokenize(readPart);
+  if (tokens.length === 0)
+    return null;
+  const verb = tokens[0];
+  if (verb !== "cat" && verb !== "head" && verb !== "tail")
+    return null;
+  const operands = [];
+  for (let i = 1; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.startsWith("-")) {
+      if ((verb === "head" || verb === "tail") && (tok === "-n" || tok === "--lines"))
+        i++;
+      continue;
+    }
+    operands.push(tok);
+    if (operands.length > 1)
+      return null;
+  }
+  return operands.length === 1 ? stripQuotes(operands[0]) : null;
+}
+function hasTraversal(virtualPath) {
+  return virtualPath.split("/").includes("..");
+}
+function tryGraphRead(rewrittenCommand, cwd) {
+  const ls = rewrittenCommand.replace(/\s+2>\S+/g, "").trim().match(/^ls\s+(?:-\S+\s+)*(\S+)\s*$/);
+  if (ls) {
+    const dir = stripQuotes(ls[1]).replace(/\/+$/, "") || "/";
+    if (dir === GRAPH_ROOT)
+      return "index.md\nfind/\nquery/\nshow/\nimpact/\nneighborhood/\nlayers\ntour\npath/\n";
+    return null;
+  }
+  const virtualPath = parseReadTargetPath(rewrittenCommand);
+  if (virtualPath === null)
+    return null;
+  if (hasTraversal(virtualPath))
+    return null;
+  const normalized = virtualPath.replace(/\/+$/, "") || "/";
+  if (normalized === GRAPH_ROOT)
+    return "index.md\nfind/\nquery/\nshow/\nimpact/\nneighborhood/\nlayers\ntour\npath/\n";
+  if (!virtualPath.startsWith(GRAPH_PREFIX))
+    return null;
+  const subpath = virtualPath.slice(GRAPH_PREFIX.length);
+  const result = handleGraphVfs(subpath, cwd);
+  return result.kind === "ok" ? result.body : `(${result.kind}) ${result.message}`;
+}
+
 // dist/src/hooks/virtual-table-query.js
 function normalizeSessionPart(path, content) {
   return normalizeContent(path, content);
@@ -2968,20 +4179,20 @@ async function executeCompiledBashCommand(api, memoryTable, sessionsTable, cmd,
 }
 
 // dist/src/hooks/query-cache.js
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join10 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 var log5 = (msg) => log("query-cache", msg);
-var DEFAULT_CACHE_ROOT = join10(homedir8(), ".deeplake", "query-cache");
+var DEFAULT_CACHE_ROOT = join14(homedir9(), ".deeplake", "query-cache");
 var INDEX_CACHE_FILE = "index.md";
 function getSessionQueryCacheDir(sessionId, deps = {}) {
   const { cacheRoot = DEFAULT_CACHE_ROOT } = deps;
-  return join10(cacheRoot, sessionId);
+  return join14(cacheRoot, sessionId);
 }
 function readCachedIndexContent(sessionId, deps = {}) {
   const { logFn = log5 } = deps;
   try {
-    return readFileSync7(join10(getSessionQueryCacheDir(sessionId, deps), INDEX_CACHE_FILE), "utf-8");
+    return readFileSync10(join14(getSessionQueryCacheDir(sessionId, deps), INDEX_CACHE_FILE), "utf-8");
   } catch (e) {
     if (e?.code === "ENOENT")
       return null;
@@ -2993,31 +4204,31 @@ function writeCachedIndexContent(sessionId, content, deps = {}) {
   const { logFn = log5 } = deps;
   try {
     const dir = getSessionQueryCacheDir(sessionId, deps);
-    mkdirSync5(dir, { recursive: true });
-    writeFileSync5(join10(dir, INDEX_CACHE_FILE), content, "utf-8");
+    mkdirSync9(dir, { recursive: true });
+    writeFileSync8(join14(dir, INDEX_CACHE_FILE), content, "utf-8");
   } catch (e) {
     logFn(`write failed for session=${sessionId}: ${e.message}`);
   }
 }
 
 // dist/src/utils/direct-run.js
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function isDirectRun(metaUrl) {
   const entry = process.argv[1];
   if (!entry)
     return false;
   try {
-    return resolve2(fileURLToPath2(metaUrl)) === resolve2(entry);
+    return resolve3(fileURLToPath2(metaUrl)) === resolve3(entry);
   } catch {
     return false;
   }
 }
 
 // dist/src/hooks/memory-path-utils.js
-import { homedir as homedir9 } from "node:os";
-import { join as join11 } from "node:path";
-var MEMORY_PATH = join11(homedir9(), ".deeplake", "memory");
+import { homedir as homedir10 } from "node:os";
+import { join as join15 } from "node:path";
+var MEMORY_PATH = join15(homedir10(), ".deeplake", "memory");
 var TILDE_PATH = "~/.deeplake/memory";
 var HOME_VAR_PATH = "$HOME/.deeplake/memory";
 var SAFE_BUILTINS = /* @__PURE__ */ new Set([
@@ -3184,6 +4395,11 @@ async function processCodexPreToolUse(input, deps = {}) {
   if (!touchesMemory(cmd))
     return { action: "pass" };
   const rewritten = rewritePaths(cmd);
+  const graphBody = tryGraphRead(rewritten, input.cwd ?? process.cwd());
+  if (graphBody !== null) {
+    logFn(`graph vfs intercept: ${rewritten}`);
+    return { action: "block", output: graphBody, rewrittenCommand: rewritten };
+  }
   if (!isSafe(rewritten)) {
     logFn(`unsupported command, blocking with guidance: ${rewritten}`);
     return {