@deeplake/hivemind 0.7.44 → 0.7.46

package/bundle/cli.js

@@ -144,23 +144,23 @@ function warn(msg) {
 function confirm(message, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve2) => {
+  return new Promise((resolve6) => {
     rl.question(`${message} ${hint} `, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
       if (a === "")
-        resolve2(defaultYes);
+        resolve6(defaultYes);
       else
-        resolve2(a === "y" || a === "yes");
+        resolve6(a === "y" || a === "yes");
     });
   });
 }
 function promptLine(message) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve2) => {
+  return new Promise((resolve6) => {
     rl.question(message, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve6(answer.trim());
     });
   });
 }
@@ -4431,6 +4431,7 @@ function loadConfig() {
     tableName: process.env.HIVEMIND_TABLE ?? "memory",
     sessionsTableName: process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions",
     skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    codebaseTableName: process.env.HIVEMIND_CODEBASE_TABLE ?? "codebase",
     memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join16(home, ".deeplake", "memory")
   };
 }
@@ -4536,9 +4537,33 @@ function validateSchema(label, cols) {
     }
   }
 }
+var CODEBASE_COLUMNS = Object.freeze([
+  // Identity key (matches the PK below)
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "repo_slug", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "user_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "worktree_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "commit_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Observation metadata
+  { name: "parent_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "branch", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TIMESTAMP" },
+  { name: "pushed_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Snapshot payload
+  { name: "snapshot_sha256", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "snapshot_jsonb", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "node_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "edge_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // Generator metadata (for drift diagnostics — what hivemind version produced this?)
+  { name: "generator", sql: "TEXT NOT NULL DEFAULT 'hivemind-graph'" },
+  { name: "generator_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "schema_version", sql: "BIGINT NOT NULL DEFAULT 1" }
+]);
 validateSchema("MEMORY_COLUMNS", MEMORY_COLUMNS);
 validateSchema("SESSIONS_COLUMNS", SESSIONS_COLUMNS);
 validateSchema("SKILLS_COLUMNS", SKILLS_COLUMNS);
+validateSchema("CODEBASE_COLUMNS", CODEBASE_COLUMNS);
 function buildCreateTableSql(tableName, cols) {
   const safe = sqlIdent(tableName);
   const colSql = cols.map((c) => `${c.name} ${c.sql}`).join(", ");
@@ -4745,7 +4770,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -4775,7 +4800,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve2) => this.waiting.push(resolve2));
+    await new Promise((resolve6) => this.waiting.push(resolve6));
   }
   release() {
     this.active--;
@@ -5085,6 +5110,24 @@ var DeeplakeApi = class {
    * This sidesteps the Deeplake UPDATE-coalescing quirk that bit the wiki
    * worker.
    */
+  /**
+   * Create the codebase table. One row per (org, workspace, repo, user,
+   * worktree, commit) — see CODEBASE_COLUMNS for the schema. Healing
+   * + index follow the same pattern as ensureSessionsTable.
+   */
+  async ensureCodebaseTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log4(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, CODEBASE_COLUMNS), safe);
+      log4(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, CODEBASE_COLUMNS);
+    await this.ensureLookupIndex(safe, "codebase_identity", `("org_id", "workspace_id", "repo_slug", "user_id", "worktree_id", "commit_sha")`);
+  }
   async ensureSkillsTable(name) {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
@@ -5410,32 +5453,2061 @@ async function runAuthCommand(args) {
       console.log("Commands: login, logout, whoami, org list, org switch, workspaces, workspace, sessions prune, invite, members, remove, autoupdate");
   }
 }
-if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
-  runAuthCommand(process.argv.slice(2)).catch((e) => {
-    console.error(e.message);
-    process.exit(1);
-  });
+if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
+  runAuthCommand(process.argv.slice(2)).catch((e) => {
+    console.error(e.message);
+    process.exit(1);
+  });
+}
+
+// dist/src/commands/graph.js
+import { execSync as execSync3 } from "node:child_process";
+import { readFileSync as readFileSync20, readdirSync as readdirSync2 } from "node:fs";
+import { join as join27, relative, resolve as resolve4, sep } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+
+// dist/src/graph/cache.js
+import { createHash } from "node:crypto";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync15, renameSync as renameSync4, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname3, join as join20 } from "node:path";
+var CACHE_SCHEMA_VERSION = 1;
+function fileContentHash(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+function cacheDir(baseDir) {
+  return join20(baseDir, ".cache");
+}
+function cachePath(baseDir, contentSha256) {
+  return join20(cacheDir(baseDir), `${contentSha256}.json`);
+}
+function readCache(baseDir, contentSha256, relativePath) {
+  const path = cachePath(baseDir, contentSha256);
+  if (!existsSync15(path))
+    return null;
+  let raw;
+  try {
+    raw = readFileSync15(path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || parsed.schema !== CACHE_SCHEMA_VERSION || parsed.content_sha256 !== contentSha256) {
+    return null;
+  }
+  const cached = parsed.extraction;
+  if (cached === void 0 || typeof cached !== "object" || !Array.isArray(cached.nodes) || !Array.isArray(cached.edges) || !Array.isArray(cached.parse_errors)) {
+    return null;
+  }
+  if (!validateItems(cached)) {
+    return null;
+  }
+  try {
+    return rewriteSourceFile(cached, relativePath);
+  } catch {
+    return null;
+  }
+}
+function validateItems(ex) {
+  if (typeof ex.source_file !== "string")
+    return false;
+  if (typeof ex.language !== "string")
+    return false;
+  for (const n of ex.nodes) {
+    if (n === null || typeof n !== "object")
+      return false;
+    if (typeof n.id !== "string")
+      return false;
+    if (typeof n.label !== "string")
+      return false;
+    if (typeof n.kind !== "string")
+      return false;
+    if (typeof n.source_file !== "string")
+      return false;
+    if (typeof n.source_location !== "string")
+      return false;
+    if (typeof n.language !== "string")
+      return false;
+    if (typeof n.exported !== "boolean")
+      return false;
+  }
+  for (const e of ex.edges) {
+    if (e === null || typeof e !== "object")
+      return false;
+    if (typeof e.source !== "string")
+      return false;
+    if (typeof e.target !== "string")
+      return false;
+    if (typeof e.relation !== "string")
+      return false;
+    if (typeof e.confidence !== "string")
+      return false;
+    if (e.ord !== void 0 && typeof e.ord !== "number")
+      return false;
+  }
+  for (const p of ex.parse_errors) {
+    if (p === null || typeof p !== "object")
+      return false;
+    if (typeof p.source_file !== "string")
+      return false;
+    if (typeof p.message !== "string")
+      return false;
+    if (p.location !== void 0 && typeof p.location !== "string")
+      return false;
+  }
+  return true;
+}
+function writeCache(baseDir, contentSha256, extraction) {
+  const entry = {
+    schema: CACHE_SCHEMA_VERSION,
+    content_sha256: contentSha256,
+    extraction
+  };
+  const path = cachePath(baseDir, contentSha256);
+  try {
+    mkdirSync7(dirname3(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync11(tmp, JSON.stringify(entry));
+    renameSync4(tmp, path);
+  } catch {
+  }
+}
+function rewriteSourceFile(cached, newPath) {
+  const oldPath = cached.source_file;
+  if (oldPath === newPath) {
+    return cached;
+  }
+  const swap = (id) => {
+    if (id.startsWith(`${oldPath}:`))
+      return `${newPath}${id.slice(oldPath.length)}`;
+    if (id.startsWith(`unresolved:${oldPath}:`)) {
+      return `unresolved:${newPath}${id.slice(`unresolved:${oldPath}`.length)}`;
+    }
+    return id;
+  };
+  return {
+    source_file: newPath,
+    language: cached.language,
+    // The synthetic module node uses source_file as its `label` (see
+    // makeModuleNode in the extractor). On a cache hit after a rename/copy
+    // we already rewrite `id` + `source_file`, but were leaving `label`
+    // pointing at the OLD path — the snapshot then disagreed with a
+    // fresh (non-cached) extraction. Rewrite `label` for module nodes too.
+    // CodeRabbit P1.
+    nodes: cached.nodes.map((n) => ({
+      ...n,
+      id: swap(n.id),
+      label: n.kind === "module" ? newPath : n.label,
+      source_file: newPath
+    })),
+    edges: cached.edges.map((e) => ({ ...e, source: swap(e.source), target: swap(e.target) })),
+    parse_errors: cached.parse_errors.map((p) => ({ ...p, source_file: newPath }))
+  };
+}
+
+// dist/src/graph/deeplake-push.js
+import { createHash as createHash2 } from "node:crypto";
+async function pushSnapshot(snapshot, worktreeId, deps = {}) {
+  if (process.env.HIVEMIND_GRAPH_PUSH === "0") {
+    return { kind: "skipped-disabled" };
+  }
+  const config = (deps.loadConfig ?? loadConfig)();
+  if (config === null) {
+    return { kind: "skipped-no-auth" };
+  }
+  const commitSha = snapshot.graph.commit_sha;
+  if (commitSha === null) {
+    return { kind: "skipped-no-commit" };
+  }
+  const api = (deps.makeApi ?? defaultMakeApi)(config);
+  try {
+    await api.ensureCodebaseTable(config.codebaseTableName);
+  } catch (err) {
+    return errorOutcome("ensureCodebaseTable", err);
+  }
+  const snapshotSha256 = computeSnapshotSha256(snapshot);
+  const tableId = sqlIdent(config.codebaseTableName);
+  const repoSlug = snapshot.graph.repo_key;
+  const userId = config.userName;
+  const selectSql = `SELECT snapshot_sha256 FROM "${tableId}" WHERE org_id = '${sqlStr(config.orgId)}' AND workspace_id = '${sqlStr(config.workspaceId)}' AND repo_slug = '${sqlStr(repoSlug)}' AND user_id = '${sqlStr(userId)}' AND worktree_id = '${sqlStr(worktreeId)}' AND commit_sha = '${sqlStr(commitSha)}'`;
+  let existing;
+  try {
+    existing = await api.query(selectSql);
+  } catch (err) {
+    return errorOutcome("SELECT existing", err);
+  }
+  if (existing.length > 0) {
+    const cloudSha = String(existing[0].snapshot_sha256 ?? "");
+    if (cloudSha === snapshotSha256) {
+      return { kind: "already-current", commitSha };
+    }
+    return {
+      kind: "drift",
+      commitSha,
+      localSha256: snapshotSha256,
+      cloudSha256: cloudSha
+    };
+  }
+  const canonical = canonicalJSON(snapshot);
+  const observation = snapshot.observation;
+  const insertSql = `INSERT INTO "${tableId}" (org_id, workspace_id, repo_slug, user_id, worktree_id, commit_sha, parent_sha, branch, ts, pushed_by, snapshot_sha256, snapshot_jsonb, node_count, edge_count, generator, generator_version, schema_version) VALUES ('${sqlStr(config.orgId)}', '${sqlStr(config.workspaceId)}', '${sqlStr(repoSlug)}', '${sqlStr(userId)}', '${sqlStr(worktreeId)}', '${sqlStr(commitSha)}', '', '${sqlStr(observation.branch ?? "")}', '${sqlStr(observation.ts)}', '${sqlStr(userId)}', '${sqlStr(snapshotSha256)}', '${sqlStr(canonical)}', ${snapshot.nodes.length}, ${snapshot.links.length}, '${sqlStr(snapshot.graph.generator)}', '${sqlStr(observation.generator_version)}', ${snapshot.graph.schema_version})`;
+  try {
+    await api.query(insertSql);
+  } catch (err) {
+    return errorOutcome("INSERT", err);
+  }
+  try {
+    const verify = await api.query(selectSql);
+    if (verify.length > 1) {
+      return { kind: "inserted-with-duplicate-race", commitSha, rowCount: verify.length };
+    }
+  } catch {
+  }
+  return { kind: "inserted", commitSha };
+}
+function defaultMakeApi(config) {
+  return new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.tableName);
+}
+function errorOutcome(stage, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return { kind: "error", message: `${stage}: ${message}` };
+}
+function computeSnapshotSha256(snapshot) {
+  const stable = {
+    directed: snapshot.directed,
+    multigraph: snapshot.multigraph,
+    graph: snapshot.graph,
+    nodes: snapshot.nodes,
+    links: snapshot.links
+  };
+  return createHash2("sha256").update(canonicalJSON(stable)).digest("hex");
+}
+function canonicalJSON(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      const sorted = {};
+      for (const k of Object.keys(v).sort()) {
+        sorted[k] = v[k];
+      }
+      return sorted;
+    }
+    return v;
+  });
+}
+
+// dist/src/graph/deeplake-pull.js
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, renameSync as renameSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname7, join as join24 } from "node:path";
+
+// dist/src/utils/repo-identity.js
+import { execSync as execSync2 } from "node:child_process";
+import { createHash as createHash3 } 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 = execSync2("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 = createHash3("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/graph/last-build.js
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync5, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname4, join as join21 } from "node:path";
+function lastBuildPath(baseDir, worktreeId) {
+  if (worktreeId !== void 0) {
+    return join21(baseDir, "worktrees", worktreeId, ".last-build.json");
+  }
+  return join21(baseDir, ".last-build.json");
+}
+function writeLastBuild(baseDir, state, worktreeId) {
+  const path = lastBuildPath(baseDir, worktreeId);
+  try {
+    mkdirSync8(dirname4(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync12(tmp, JSON.stringify(state));
+    renameSync5(tmp, path);
+  } catch {
+  }
+}
+function readLastBuild(baseDir, worktreeId) {
+  let path = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync16(path)) {
+    if (worktreeId === void 0)
+      return null;
+    const legacy = lastBuildPath(baseDir, void 0);
+    if (!existsSync16(legacy))
+      return null;
+    path = legacy;
+  }
+  let raw;
+  try {
+    raw = readFileSync16(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/history.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync17 } from "node:fs";
+import { dirname as dirname5, join as join22 } from "node:path";
+function historyPath(baseDir) {
+  return join22(baseDir, "history.jsonl");
+}
+function appendHistoryEntry(baseDir, entry) {
+  const path = historyPath(baseDir);
+  try {
+    mkdirSync9(dirname5(path), { recursive: true });
+    appendFileSync2(path, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+function entryFromSnapshot(snapshot, snapshot_sha256, trigger) {
+  return {
+    ts: snapshot.observation.ts,
+    commit_sha: snapshot.graph.commit_sha,
+    snapshot_sha256,
+    node_count: snapshot.nodes.length,
+    edge_count: snapshot.links.length,
+    trigger
+  };
+}
+function readHistoryTail(baseDir, n) {
+  const path = historyPath(baseDir);
+  if (!existsSync17(path))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync17(path, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const entries = [];
+  for (let i = lines.length - 1; i >= 0 && entries.length < n; i--) {
+    const parsed = parseLine(lines[i]);
+    if (parsed !== null)
+      entries.unshift(parsed);
+  }
+  return entries;
+}
+function countHistoryEntries(baseDir) {
+  const path = historyPath(baseDir);
+  if (!existsSync17(path))
+    return 0;
+  try {
+    const raw = readFileSync17(path, "utf8");
+    return raw.split("\n").filter((l) => l.length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+function parseLine(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (obj === null || typeof obj !== "object")
+    return null;
+  const o = obj;
+  if (typeof o.ts !== "string")
+    return null;
+  if (o.commit_sha !== null && typeof o.commit_sha !== "string")
+    return null;
+  if (typeof o.snapshot_sha256 !== "string")
+    return null;
+  if (typeof o.node_count !== "number")
+    return null;
+  if (typeof o.edge_count !== "number")
+    return null;
+  if (typeof o.trigger !== "string")
+    return null;
+  return {
+    ts: o.ts,
+    commit_sha: o.commit_sha,
+    snapshot_sha256: o.snapshot_sha256,
+    node_count: o.node_count,
+    edge_count: o.edge_count,
+    trigger: o.trigger
+  };
+}
+
+// dist/src/graph/snapshot.js
+import { createHash as createHash4 } from "node:crypto";
+import { mkdirSync as mkdirSync10, renameSync as renameSync6, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname6, join as join23 } from "node:path";
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join23(homedir10(), ".hivemind", "graphs");
+}
+function repoDir(repoKey) {
+  return join23(graphsRoot(), repoKey);
+}
+function buildSnapshot(extractions, metadata, observation) {
+  const nodes = [];
+  const links = [];
+  for (const ex of extractions) {
+    for (const n of ex.nodes)
+      nodes.push(n);
+    for (const e of ex.edges)
+      links.push(e);
+  }
+  nodes.sort(compareNodes);
+  links.sort(compareEdges);
+  return {
+    directed: true,
+    multigraph: true,
+    graph: metadata,
+    observation,
+    nodes,
+    links
+  };
+}
+function compareNodes(a, b) {
+  return cmp(a.id, b.id);
+}
+function compareEdges(a, b) {
+  let c = cmp(a.source, b.source);
+  if (c !== 0)
+    return c;
+  c = cmp(a.target, b.target);
+  if (c !== 0)
+    return c;
+  c = cmp(a.relation, b.relation);
+  if (c !== 0)
+    return c;
+  return (a.ord ?? 0) - (b.ord ?? 0);
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function canonicalSnapshot(snapshot) {
+  return canonicalJSON2(snapshot);
+}
+function computeSnapshotSha2562(snapshot) {
+  const stable = {
+    directed: snapshot.directed,
+    multigraph: snapshot.multigraph,
+    graph: snapshot.graph,
+    nodes: snapshot.nodes,
+    links: snapshot.links
+  };
+  return createHash4("sha256").update(canonicalJSON2(stable)).digest("hex");
+}
+function canonicalJSON2(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      const sorted = {};
+      for (const k of Object.keys(v).sort()) {
+        sorted[k] = v[k];
+      }
+      return sorted;
+    }
+    return v;
+  });
+}
+function writeSnapshot(snapshot, baseDir, trigger = "unknown", worktreeId) {
+  const sha256 = computeSnapshotSha2562(snapshot);
+  const commitSha = snapshot.graph.commit_sha;
+  const fileBase = commitSha ?? sha256;
+  const snapshotsDir = join23(baseDir, "snapshots");
+  const snapshotPath = join23(snapshotsDir, `${fileBase}.json`);
+  const canonical = canonicalSnapshot(snapshot);
+  writeFileAtomic(snapshotPath, canonical);
+  const worktreeRoot = worktreeId !== void 0 ? join23(baseDir, "worktrees", worktreeId) : baseDir;
+  let latestCommitPath = null;
+  if (commitSha !== null) {
+    latestCommitPath = join23(worktreeRoot, "latest-commit.txt");
+    writeFileAtomic(latestCommitPath, `${commitSha}
+`);
+  }
+  writeLastBuild(baseDir, {
+    ts: Date.now(),
+    commit_sha: commitSha,
+    snapshot_sha256: sha256,
+    node_count: snapshot.nodes.length,
+    edge_count: snapshot.links.length
+  }, worktreeId);
+  appendHistoryEntry(baseDir, entryFromSnapshot(snapshot, sha256, trigger));
+  return { snapshotPath, latestCommitPath, snapshotSha256: sha256 };
+}
+function writeFileAtomic(filePath, contents) {
+  mkdirSync10(dirname6(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync13(tmp, contents);
+  renameSync6(tmp, filePath);
+}
+
+// dist/src/graph/deeplake-pull.js
+function workTreeIdFor(cwd) {
+  return createHash5("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+async function pullSnapshot(cwd, deps = {}) {
+  if (process.env.HIVEMIND_GRAPH_PULL === "0") {
+    return { kind: "skipped-disabled" };
+  }
+  const config = (deps.loadConfig ?? loadConfig)();
+  if (config === null) {
+    return { kind: "skipped-no-auth" };
+  }
+  const head = (deps.readHead ?? defaultReadHead)(cwd);
+  if (head === null) {
+    return { kind: "skipped-no-head" };
+  }
+  const api = (deps.makeApi ?? defaultMakeApi2)(config);
+  try {
+    await api.ensureCodebaseTable(config.codebaseTableName);
+  } catch (err) {
+    return errorOutcome2("ensureCodebaseTable", err);
+  }
+  const tableId = sqlIdent(config.codebaseTableName);
+  const { key: repoKey } = deriveProjectKey(cwd);
+  const selectSql = `SELECT snapshot_jsonb, snapshot_sha256, ts, node_count, edge_count, branch, generator_version, worktree_id FROM "${tableId}" WHERE org_id = '${sqlStr(config.orgId)}' AND workspace_id = '${sqlStr(config.workspaceId)}' AND repo_slug = '${sqlStr(repoKey)}' AND user_id = '${sqlStr(config.userName)}' AND commit_sha = '${sqlStr(head)}' ORDER BY ts DESC LIMIT 1`;
+  let rows;
+  try {
+    rows = await api.query(selectSql);
+  } catch (err) {
+    return errorOutcome2("SELECT cloud row", err);
+  }
+  if (rows.length === 0) {
+    return { kind: "no-cloud-row", commitSha: head };
+  }
+  const row = rows[0];
+  const cloudSha256 = String(row.snapshot_sha256 ?? "").trim();
+  const cloudPayload = coerceSnapshotPayload(row.snapshot_jsonb);
+  if (cloudPayload === null) {
+    return errorOutcome2("SELECT cloud row", new Error("invalid snapshot_jsonb payload"));
+  }
+  if (cloudSha256 !== "") {
+    const computedSha = createHash5("sha256").update(cloudPayload).digest("hex");
+    if (cloudSha256 !== computedSha) {
+      return errorOutcome2("SELECT cloud row", new Error(`snapshot_sha256 mismatch (expected ${cloudSha256}, got ${computedSha})`));
+    }
+  }
+  const cloudTs = parseTs(row.ts);
+  const baseDir = repoDir(repoKey);
+  const worktreeId = workTreeIdFor(cwd);
+  const local = readLastBuild(baseDir, worktreeId);
+  if (local !== null && local.commit_sha === head) {
+    if (cloudSha256 !== "" && local.snapshot_sha256 === cloudSha256) {
+      return { kind: "up-to-date", commitSha: head, snapshotSha256: cloudSha256 };
+    }
+    if (local.ts > cloudTs) {
+      return {
+        kind: "local-newer",
+        commitSha: head,
+        localTs: local.ts,
+        cloudTs
+      };
+    }
+  }
+  const snapshotsDir = join24(baseDir, "snapshots");
+  const snapshotPath = join24(snapshotsDir, `${head}.json`);
+  const worktreeRoot = join24(baseDir, "worktrees", worktreeId);
+  try {
+    writeFileAtomic2(snapshotPath, cloudPayload);
+    writeFileAtomic2(join24(worktreeRoot, "latest-commit.txt"), `${head}
+`);
+    writeLastBuild(baseDir, {
+      ts: cloudTs,
+      commit_sha: head,
+      snapshot_sha256: cloudSha256,
+      node_count: numOrUndefined(row.node_count),
+      edge_count: numOrUndefined(row.edge_count)
+    }, worktreeId);
+    appendHistoryEntry(baseDir, {
+      ts: new Date(cloudTs).toISOString(),
+      commit_sha: head,
+      snapshot_sha256: cloudSha256,
+      node_count: Number(row.node_count ?? 0),
+      edge_count: Number(row.edge_count ?? 0),
+      trigger: "pull"
+    });
+  } catch (err) {
+    return errorOutcome2("write local files", err);
+  }
+  return {
+    kind: "pulled",
+    commitSha: head,
+    snapshotSha256: cloudSha256,
+    bytes: Buffer.byteLength(cloudPayload, "utf8"),
+    cloudTs,
+    sourceWorktreePath: String(row.worktree_id ?? "")
+  };
+}
+function defaultReadHead(cwd) {
+  try {
+    return execFileSync4("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function defaultMakeApi2(config) {
+  return new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.tableName);
+}
+function parseTs(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw < 1e12 ? raw * 1e3 : raw;
+  }
+  if (typeof raw === "string") {
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function numOrUndefined(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0)
+    return raw;
+  if (typeof raw === "string") {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n >= 0)
+      return n;
+  }
+  return void 0;
+}
+function coerceSnapshotPayload(raw) {
+  if (typeof raw === "string")
+    return raw;
+  if (raw !== null && typeof raw === "object")
+    return JSON.stringify(raw);
+  return null;
+}
+function writeFileAtomic2(filePath, contents) {
+  mkdirSync11(dirname7(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync14(tmp, contents);
+  renameSync7(tmp, filePath);
+}
+function errorOutcome2(stage, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return { kind: "error", message: `${stage}: ${message}` };
+}
+
+// dist/src/graph/diff.js
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { join as join25 } from "node:path";
+function edgeKey(e) {
+  return `${e.source}
${e.target}
${e.relation}
${e.ord ?? 0}`;
+}
+function diffSnapshots(from, to) {
+  const fromNodeIds = new Set(from.nodes.map((n) => n.id));
+  const toNodeIds = new Set(to.nodes.map((n) => n.id));
+  const nodesAdded = to.nodes.filter((n) => !fromNodeIds.has(n.id));
+  const nodesRemoved = from.nodes.filter((n) => !toNodeIds.has(n.id));
+  const fromEdgeKeys = new Set(from.links.map(edgeKey));
+  const toEdgeKeys = new Set(to.links.map(edgeKey));
+  const edgesAdded = to.links.filter((e) => !fromEdgeKeys.has(edgeKey(e)));
+  const edgesRemoved = from.links.filter((e) => !toEdgeKeys.has(edgeKey(e)));
+  return {
+    nodes: { added: nodesAdded, removed: nodesRemoved },
+    edges: { added: edgesAdded, removed: edgesRemoved },
+    counts: {
+      nodes_added: nodesAdded.length,
+      nodes_removed: nodesRemoved.length,
+      edges_added: edgesAdded.length,
+      edges_removed: edgesRemoved.length
+    }
+  };
+}
+function loadSnapshotByCommit(baseDir, commitSha) {
+  if (!/^[0-9a-f]{4,64}$/i.test(commitSha))
+    return null;
+  const path = join25(baseDir, "snapshots", `${commitSha}.json`);
+  if (!existsSync19(path))
+    return null;
+  let raw;
+  try {
+    raw = readFileSync18(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isGraphSnapshotLike(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isGraphSnapshotLike(v) {
+  if (v === null || typeof v !== "object")
+    return false;
+  const s = v;
+  return Array.isArray(s.nodes) && Array.isArray(s.links);
+}
+function printDiffHuman(diff, sampleSize = 10) {
+  const { counts } = diff;
+  console.log(`Nodes: +${counts.nodes_added} -${counts.nodes_removed}   Edges: +${counts.edges_added} -${counts.edges_removed}`);
+  const showNodes = (label, ns) => {
+    if (ns.length === 0)
+      return;
+    console.log("");
+    console.log(`${label} (${ns.length}, showing up to ${sampleSize}):`);
+    const sorted = [...ns].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    for (const n of sorted.slice(0, sampleSize)) {
+      console.log(`  ${n.id} [${n.kind}]${n.exported ? " (exported)" : ""}  ${n.source_file}:${n.source_location}`);
+    }
+    if (sorted.length > sampleSize)
+      console.log(`  \u2026 and ${sorted.length - sampleSize} more`);
+  };
+  const showEdges = (label, es) => {
+    if (es.length === 0)
+      return;
+    console.log("");
+    console.log(`${label} (${es.length}, showing up to ${sampleSize}):`);
+    const sorted = [...es].sort((a, b) => edgeKey(a) < edgeKey(b) ? -1 : edgeKey(a) > edgeKey(b) ? 1 : 0);
+    for (const e of sorted.slice(0, sampleSize)) {
+      console.log(`  ${e.source} --${e.relation}--> ${e.target}${e.ord !== void 0 ? ` (ord=${e.ord})` : ""}`);
+    }
+    if (sorted.length > sampleSize)
+      console.log(`  \u2026 and ${sorted.length - sampleSize} more`);
+  };
+  showNodes("Nodes added", diff.nodes.added);
+  showNodes("Nodes removed", diff.nodes.removed);
+  showEdges("Edges added", diff.edges.added);
+  showEdges("Edges removed", diff.edges.removed);
+}
+
+// dist/src/graph/extract/typescript.js
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+var _typescriptParser = null;
+var _tsxParser = null;
+function getTypescriptParser() {
+  if (_typescriptParser === null) {
+    _typescriptParser = new Parser();
+    _typescriptParser.setLanguage(TypeScript.typescript);
+  }
+  return _typescriptParser;
+}
+function getTsxParser() {
+  if (_tsxParser === null) {
+    _tsxParser = new Parser();
+    _tsxParser.setLanguage(TypeScript.tsx);
+  }
+  return _tsxParser;
+}
+function pickParserForPath(relativePath) {
+  return relativePath.endsWith(".tsx") || relativePath.endsWith(".jsx") ? getTsxParser() : getTypescriptParser();
+}
+function extractTypeScript(sourceCode, relativePath) {
+  const parser = pickParserForPath(relativePath);
+  const CHUNK_BYTES = 16384;
+  const tree = parser.parse((index) => {
+    if (index >= sourceCode.length)
+      return null;
+    return sourceCode.slice(index, index + CHUNK_BYTES);
+  });
+  const root = tree.rootNode;
+  const result = {
+    source_file: relativePath,
+    language: "typescript",
+    nodes: [],
+    edges: [],
+    parse_errors: []
+  };
+  collectParseErrors(root, relativePath, result.parse_errors);
+  const moduleNode = makeModuleNode(relativePath);
+  result.nodes.push(moduleNode);
+  const declByName = /* @__PURE__ */ new Map();
+  extractDeclarations(root, relativePath, result, declByName, moduleNode);
+  extractImports(root, relativePath, result, moduleNode);
+  extractCalls(root, relativePath, result, declByName);
+  return result;
+}
+function collectParseErrors(node, relativePath, out) {
+  if (node.isError || node.isMissing) {
+    out.push({
+      source_file: relativePath,
+      message: node.isMissing ? `missing node: ${node.type}` : `parse error at ${locationStr(node)}`,
+      location: locationStr(node)
+    });
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null)
+      collectParseErrors(child, relativePath, out);
+  }
+}
+function extractDeclarations(node, relativePath, result, declByName, moduleNode) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child === null)
+      continue;
+    const { decl, exported } = unwrapExport(child);
+    if (decl !== null) {
+      handleDeclaration(decl, exported, relativePath, result, declByName, moduleNode);
+    }
+    if (child.type === "internal_module" || child.type === "module") {
+      extractDeclarations(child, relativePath, result, declByName, moduleNode);
+    }
+  }
+}
+function unwrapExport(node) {
+  if (node.type === "export_statement") {
+    const decl = node.childForFieldName("declaration") ?? firstNamedChildOfTypes(node, [
+      "function_declaration",
+      "class_declaration",
+      "interface_declaration",
+      "type_alias_declaration",
+      "enum_declaration",
+      "lexical_declaration"
+    ]);
+    return { decl, exported: true };
+  }
+  return { decl: node, exported: false };
+}
+function handleDeclaration(node, exported, relativePath, result, declByName, moduleNode) {
+  switch (node.type) {
+    case "function_declaration": {
+      const name = textOfField(node, "name");
+      if (name === null)
+        return;
+      const decl = makeNode(relativePath, name, "function", node, exported);
+      pushNode(result, declByName, decl);
+      return;
+    }
+    case "class_declaration": {
+      const name = textOfField(node, "name");
+      if (name === null)
+        return;
+      const classNode = makeNode(relativePath, name, "class", node, exported);
+      pushNode(result, declByName, classNode);
+      const heritage = firstNamedChildOfTypes(node, ["class_heritage"]);
+      if (heritage !== null) {
+        for (let i = 0; i < heritage.namedChildCount; i++) {
+          const clause = heritage.namedChild(i);
+          if (clause === null)
+            continue;
+          const relation = clause.type === "extends_clause" ? "extends" : clause.type === "implements_clause" ? "implements" : null;
+          if (relation === null)
+            continue;
+          for (let j = 0; j < clause.namedChildCount; j++) {
+            const base = clause.namedChild(j);
+            if (base === null)
+              continue;
+            const baseName = base.text;
+            if (baseName.length === 0)
+              continue;
+            result.edges.push({
+              source: classNode.id,
+              target: nodeIdUnresolved(relativePath, baseName, relation === "extends" ? "class" : "interface"),
+              relation,
+              confidence: "EXTRACTED"
+            });
+          }
+        }
+      }
+      const body = firstNamedChildOfTypes(node, ["class_body"]);
+      if (body !== null) {
+        for (let i = 0; i < body.namedChildCount; i++) {
+          const member = body.namedChild(i);
+          if (member === null)
+            continue;
+          if (member.type === "method_definition") {
+            const methodName = textOfField(member, "name");
+            if (methodName === null)
+              continue;
+            const accessibility = firstNamedChildOfTypes(member, ["accessibility_modifier"]);
+            const isHardPrivate = firstNamedChildOfTypes(member, ["private_property_identifier"]) !== null;
+            const isPublic = !isHardPrivate && (accessibility === null || accessibility.text === "public");
+            const methodExported = exported && isPublic;
+            const methodKey = `${classNode.label}.${methodName}`;
+            const methodNode = makeNodeWithExplicitLabel(relativePath, methodKey, methodName, "method", member, methodExported);
+            pushNode(result, declByName, methodNode, methodKey);
+            result.edges.push({
+              source: classNode.id,
+              target: methodNode.id,
+              relation: "method_of",
+              confidence: "EXTRACTED"
+            });
+          }
+        }
+      }
+      return;
+    }
+    case "interface_declaration": {
+      const name = textOfField(node, "name");
+      if (name === null)
+        return;
+      const decl = makeNode(relativePath, name, "interface", node, exported);
+      pushNode(result, declByName, decl);
+      return;
+    }
+    case "type_alias_declaration": {
+      const name = textOfField(node, "name");
+      if (name === null)
+        return;
+      const decl = makeNode(relativePath, name, "type_alias", node, exported);
+      pushNode(result, declByName, decl);
+      return;
+    }
+    case "enum_declaration": {
+      const name = textOfField(node, "name");
+      if (name === null)
+        return;
+      const decl = makeNode(relativePath, name, "enum", node, exported);
+      pushNode(result, declByName, decl);
+      return;
+    }
+    case "lexical_declaration": {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (declarator === null || declarator.type !== "variable_declarator")
+          continue;
+        const ident = declarator.childForFieldName("name");
+        if (ident === null || ident.type !== "identifier")
+          continue;
+        const decl = makeNode(relativePath, ident.text, "const", declarator, exported);
+        pushNode(result, declByName, decl);
+      }
+      return;
+    }
+  }
+}
+function extractImports(node, relativePath, result, moduleNode) {
+  if (node.type === "import_statement") {
+    const src = firstNamedChildOfTypes(node, ["string"]);
+    if (src !== null) {
+      const frag = firstNamedChildOfTypes(src, ["string_fragment"]);
+      const specifier = (frag !== null ? frag.text : src.text).replace(/^['"]|['"]$/g, "");
+      if (specifier.length > 0) {
+        result.edges.push({
+          source: moduleNode.id,
+          target: `external:${specifier}`,
+          relation: "imports",
+          confidence: "EXTRACTED"
+        });
+      }
+    }
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null)
+      extractImports(child, relativePath, result, moduleNode);
+  }
+}
+function extractCalls(node, relativePath, result, declByName) {
+  if (node.type === "call_expression") {
+    const callee = node.childForFieldName("function");
+    if (callee !== null) {
+      const calleeKey = resolveCalleeKey(callee, declByName);
+      if (calleeKey !== null) {
+        const targetNode = declByName.get(calleeKey);
+        if (targetNode !== void 0) {
+          const callerNode = findEnclosingDeclaration(node, declByName);
+          if (callerNode !== null) {
+            result.edges.push({
+              source: callerNode.id,
+              target: targetNode.id,
+              relation: "calls",
+              confidence: "EXTRACTED"
+            });
+          }
+        }
+      }
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null)
+      extractCalls(child, relativePath, result, declByName);
+  }
+}
+function resolveCalleeKey(callee, declByName) {
+  if (callee.type === "identifier")
+    return callee.text;
+  if (callee.type === "member_expression") {
+    const object = callee.childForFieldName("object");
+    const property = callee.childForFieldName("property");
+    if (object !== null && object.type === "this" && property !== null && property.type === "property_identifier") {
+      const className = findEnclosingClassName(callee);
+      if (className !== null)
+        return `${className}.${property.text}`;
+    }
+  }
+  return null;
+}
+function findEnclosingDeclaration(node, declByName) {
+  let cur = node.parent;
+  while (cur !== null) {
+    if (cur.type === "function_declaration") {
+      const name = textOfField(cur, "name");
+      if (name !== null) {
+        const n = declByName.get(name);
+        if (n !== void 0)
+          return n;
+      }
+    } else if (cur.type === "method_definition") {
+      const methodName = textOfField(cur, "name");
+      const className = findEnclosingClassName(cur);
+      if (methodName !== null && className !== null) {
+        const n = declByName.get(`${className}.${methodName}`);
+        if (n !== void 0)
+          return n;
+      }
+    } else if (cur.type === "variable_declarator") {
+      const value = cur.childForFieldName("value");
+      if (value?.type === "arrow_function" || value?.type === "function_expression") {
+        const ident = cur.childForFieldName("name");
+        if (ident !== null && ident.type === "identifier") {
+          const n = declByName.get(ident.text);
+          if (n !== void 0)
+            return n;
+        }
+      }
+    }
+    cur = cur.parent;
+  }
+  return null;
+}
+function findEnclosingClassName(node) {
+  let cur = node.parent;
+  while (cur !== null) {
+    if (cur.type === "class_declaration") {
+      return textOfField(cur, "name");
+    }
+    cur = cur.parent;
+  }
+  return null;
+}
+function makeModuleNode(relativePath) {
+  return {
+    id: `${relativePath}::module`,
+    label: relativePath,
+    kind: "module",
+    source_file: relativePath,
+    source_location: "L1",
+    language: "typescript",
+    exported: false
+  };
+}
+function makeNode(relativePath, name, kind, node, exported) {
+  return {
+    id: nodeId(relativePath, name, kind),
+    label: name,
+    kind,
+    source_file: relativePath,
+    source_location: locationStr(node),
+    language: "typescript",
+    exported
+  };
+}
+function makeNodeWithExplicitLabel(relativePath, idName, label, kind, node, exported) {
+  return {
+    id: nodeId(relativePath, idName, kind),
+    label,
+    kind,
+    source_file: relativePath,
+    source_location: locationStr(node),
+    language: "typescript",
+    exported
+  };
+}
+function pushNode(result, declByName, node, lookupKey) {
+  if (result.nodes.some((n) => n.id === node.id)) {
+    if (!declByName.has(lookupKey ?? node.label)) {
+      declByName.set(lookupKey ?? node.label, node);
+    }
+    return;
+  }
+  result.nodes.push(node);
+  declByName.set(lookupKey ?? node.label, node);
+}
+function nodeId(relativePath, name, kind) {
+  return `${relativePath}:${name}:${kind}`;
+}
+function nodeIdUnresolved(relativePath, name, kind) {
+  return `unresolved:${relativePath}:${name}:${kind}`;
+}
+function locationStr(node) {
+  const start = node.startPosition.row + 1;
+  const end = node.endPosition.row + 1;
+  return start === end ? `L${start}` : `L${start}-${end}`;
+}
+function textOfField(node, fieldName) {
+  const child = node.childForFieldName(fieldName);
+  if (child === null)
+    return null;
+  const text = child.text;
+  return text.length > 0 ? text : null;
+}
+function firstNamedChildOfTypes(node, types) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null && types.includes(child.type))
+      return child;
+  }
+  return null;
+}
+
+// dist/src/graph/git-hook-install.js
+import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, unlinkSync as unlinkSync8, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname8, join as join26, resolve as resolve3 } from "node:path";
+import { execFileSync as execFileSync5 } from "node:child_process";
+var HOOK_BEGIN_MARKER = "# HIVEMIND_GRAPH_HOOK_BEGIN \u2014 managed by `hivemind graph init`";
+var HOOK_END_MARKER = "# HIVEMIND_GRAPH_HOOK_END";
+var SHEBANG = "#!/bin/sh";
+function hookBodyLines(hivemindPath) {
+  return [
+    "# Async-detached so commits never wait. Threshold-gate + cache make",
+    "# typical re-runs ~85ms. Logs go to ~/.hivemind/post-commit.log",
+    "# mkdir is robust against first-run: $HOME/.hivemind may not exist yet,",
+    "# in which case the > redirect would fail and the build would never start.",
+    'mkdir -p "$HOME/.hivemind" 2>/dev/null || true',
+    `nohup ${quoteForShell(hivemindPath)} graph build --trigger post-commit >> "$HOME/.hivemind/post-commit.log" 2>&1 &`
+  ];
+}
+function quoteForShell(path) {
+  return `'${path.replace(/'/g, `'\\''`)}'`;
+}
+function gitHooksDir(cwd) {
+  const configured = tryGitConfig(cwd, "core.hooksPath");
+  if (configured !== null) {
+    const top = tryGitTopLevel(cwd);
+    return top !== null ? resolve3(top, configured) : resolve3(cwd, configured);
+  }
+  try {
+    const out = execFileSync5("git", ["rev-parse", "--git-path", "hooks"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (out === "")
+      return null;
+    return resolve3(cwd, out);
+  } catch {
+    return null;
+  }
+}
+function tryGitConfig(cwd, key) {
+  try {
+    const out = execFileSync5("git", ["config", "--get", key], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out === "" ? null : out;
+  } catch {
+    return null;
+  }
+}
+function tryGitTopLevel(cwd) {
+  try {
+    const out = execFileSync5("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out === "" ? null : out;
+  } catch {
+    return null;
+  }
+}
+function postCommitHookPath(cwd) {
+  const hooksDir = gitHooksDir(cwd);
+  return hooksDir === null ? null : join26(hooksDir, "post-commit");
+}
+function installPostCommitHook(cwd, opts = {}) {
+  const path = postCommitHookPath(cwd);
+  if (path === null) {
+    return { kind: "foreign-hook", path: "", hint: "not in a git repo (no .git directory found)" };
+  }
+  const existed = existsSync20(path);
+  if (existed) {
+    const content = readFileSync19(path, "utf8");
+    if (containsOurMarkers(content)) {
+      return { kind: "already-ours", path };
+    }
+    if (!opts.force) {
+      return {
+        kind: "foreign-hook",
+        path,
+        hint: `existing hook at ${path} is not managed by hivemind; pass --force to overwrite, or merge our block manually (between '${HOOK_BEGIN_MARKER}' and '${HOOK_END_MARKER}')`
+      };
+    }
+  }
+  const hivemindPath = resolveHivemindPath();
+  if (hivemindPath === null) {
+    return {
+      kind: "foreign-hook",
+      path,
+      hint: "hivemind binary not found on PATH. Install hivemind globally (`npm install -g @deeplake/hivemind`) before running `hivemind graph init`, so the hook can find a stable absolute path to call."
+    };
+  }
+  mkdirSync12(dirname8(path), { recursive: true });
+  writeFileSync15(path, buildHookFile(hivemindPath), { mode: 493 });
+  try {
+    chmodSync2(path, 493);
+  } catch {
+  }
+  return { kind: "installed", path, wasNew: !existed };
+}
+function resolveHivemindPath() {
+  try {
+    const out = execFileSync5("which", ["hivemind"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (out !== "" && out.includes("hivemind"))
+      return out.split("\n")[0].trim();
+  } catch {
+  }
+  return null;
+}
+function uninstallPostCommitHook(cwd) {
+  const path = postCommitHookPath(cwd);
+  if (path === null) {
+    return { kind: "no-hook", path: "" };
+  }
+  if (!existsSync20(path)) {
+    return { kind: "no-hook", path };
+  }
+  const content = readFileSync19(path, "utf8");
+  if (!containsOurMarkers(content)) {
+    return {
+      kind: "not-ours",
+      path,
+      hint: `existing hook at ${path} is not managed by hivemind; remove it manually if you want it gone`
+    };
+  }
+  const stripped = stripOurBlock(content);
+  const meaningful = stripped.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#!"));
+  if (meaningful.length === 0) {
+    unlinkSync8(path);
+    return { kind: "removed", path, wholeFileDeleted: true };
+  }
+  writeFileSync15(path, stripped);
+  return { kind: "removed", path, wholeFileDeleted: false };
+}
+function containsOurMarkers(content) {
+  return content.includes(HOOK_BEGIN_MARKER) && content.includes(HOOK_END_MARKER);
+}
+function stripOurBlock(content) {
+  const beginIdx = content.indexOf(HOOK_BEGIN_MARKER);
+  const endIdx = content.indexOf(HOOK_END_MARKER);
+  if (beginIdx === -1 || endIdx === -1 || endIdx < beginIdx)
+    return content;
+  const blockEnd = endIdx + HOOK_END_MARKER.length;
+  return content.slice(0, beginIdx) + content.slice(blockEnd);
+}
+function buildHookFile(hivemindPath) {
+  return [
+    SHEBANG,
+    "",
+    HOOK_BEGIN_MARKER,
+    ...hookBodyLines(hivemindPath),
+    HOOK_END_MARKER,
+    ""
+  ].join("\n");
+}
+
+// dist/src/commands/graph.js
+var USAGE = `hivemind graph \u2014 codebase-graph commands (Phase 1 \u2014 TypeScript only)
+
+Usage:
+  hivemind graph build [--cwd <path>]
+      Walk the project for TypeScript source files, extract symbols + edges,
+      and write a snapshot to ~/.hivemind/graphs/<repo-key>/snapshots/<commit-sha>.json.
+      Also updates ~/.hivemind/graphs/<repo-key>/latest-commit.txt and the
+      per-repo .last-build.json (consumed by the SessionEnd auto-build hook).
+
+  hivemind graph diff <sha1> <sha2> [--cwd <path>] [--json] [--limit N]
+      Diff two snapshots by their git commit SHA. Prints added/removed
+      counts for nodes and edges, plus up to N=10 (default) examples of each.
+      --json: emit machine-readable JSON instead of the human format.
+      --limit N: cap the per-category examples (human format only).
+
+  hivemind graph history [--cwd <path>] [-n N] [--json]
+      Print the last N (default 20) entries from the per-repo history.jsonl,
+      newest last. Each entry shows ts, commit_sha (short), snapshot_sha256
+      (short), node/edge counts, and the trigger that fired the build.
+      --json: emit raw JSONL (one parsed entry per line, full fields).
+
+  hivemind graph init [--cwd <path>] [--force] [--no-initial-build]
+      Install a managed block in .git/hooks/post-commit that fires
+      \`hivemind graph build --trigger post-commit\` after each commit
+      (async, non-blocking, exit 0 always). Idempotent: re-running on
+      an already-installed hook is a no-op. Refuses to clobber an
+      existing non-managed hook unless --force is passed.
+      Also runs an initial \`hivemind graph build\` unless
+      --no-initial-build is passed.
+
+  hivemind graph uninstall [--cwd <path>]
+      Remove our managed block from .git/hooks/post-commit. If our block
+      was the only content, deletes the file; otherwise leaves the rest
+      intact. Snapshots and history are NOT touched (\`rm -rf
+      ~/.hivemind/graphs/<key>\` if you really want them gone).
+
+  hivemind graph pull [--cwd <path>]
+      Download the freshest cloud snapshot for HEAD into the local graph
+      dir (any worktree of this user counts). No-op if local already
+      matches cloud sha256 or local was built later than cloud. Requires
+      \`hivemind login\`. Best-effort: any network/auth failure leaves
+      the local files untouched. Disable via HIVEMIND_GRAPH_PULL=0.
+
+  hivemind graph --help
+      Show this message.
+
+  Future subcommands (Phase 1.5+): daemon, search, latest, push, pull, prune.
+`;
+var DEFAULT_IGNORES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "bundle",
+  "dist",
+  "coverage",
+  ".cache",
+  ".nyc_output"
+]);
+function runGraphCommand(args) {
+  const sub = args[0];
+  if (sub === void 0 || sub === "--help" || sub === "-h" || sub === "help") {
+    console.log(USAGE);
+    return;
+  }
+  if (sub === "build") {
+    return runBuildCommand(args.slice(1));
+  }
+  if (sub === "diff") {
+    runDiffCommand(args.slice(1));
+    return;
+  }
+  if (sub === "history") {
+    runHistoryCommand(args.slice(1));
+    return;
+  }
+  if (sub === "init") {
+    return runInitCommand(args.slice(1));
+  }
+  if (sub === "uninstall") {
+    runUninstallCommand(args.slice(1));
+    return;
+  }
+  if (sub === "pull") {
+    return runPullCommand(args.slice(1));
+  }
+  console.error(`hivemind graph: unknown subcommand '${sub}'`);
+  console.error(USAGE);
+  process.exit(2);
+}
+function parseInitArgs(args) {
+  let cwd = process.cwd();
+  let force = false;
+  let initialBuild = true;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--force") {
+      force = true;
+    } else if (a === "--no-initial-build") {
+      initialBuild = false;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph init: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd, force, initialBuild };
+}
+async function runInitCommand(args) {
+  const opts = parseInitArgs(args);
+  const status = installPostCommitHook(opts.cwd, { force: opts.force });
+  switch (status.kind) {
+    case "installed":
+      console.log(`Installed post-commit hook at ${status.path}`);
+      break;
+    case "already-ours":
+      console.log(`Post-commit hook already managed by hivemind (no change): ${status.path}`);
+      break;
+    case "foreign-hook":
+      console.error(`hivemind graph init: ${status.hint}`);
+      process.exit(1);
+  }
+  if (opts.initialBuild) {
+    console.log("");
+    console.log("Running initial build...");
+    await runBuildCommand(["--cwd", opts.cwd, "--trigger", "manual"]);
+  } else {
+    console.log("");
+    console.log("Skipped initial build (--no-initial-build). Run `hivemind graph build` when ready.");
+  }
+}
+function parseUninstallArgs(args) {
+  let cwd = process.cwd();
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph uninstall: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd };
+}
+function runUninstallCommand(args) {
+  const opts = parseUninstallArgs(args);
+  const status = uninstallPostCommitHook(opts.cwd);
+  switch (status.kind) {
+    case "removed":
+      if (status.wholeFileDeleted) {
+        console.log(`Removed post-commit hook (file deleted): ${status.path}`);
+      } else {
+        console.log(`Removed managed block from post-commit hook (other content preserved): ${status.path}`);
+      }
+      console.log("Local snapshots + history.jsonl are untouched.");
+      break;
+    case "no-hook":
+      console.log(status.path === "" ? "No git repo here (nothing to uninstall)." : `No post-commit hook at ${status.path} (nothing to uninstall).`);
+      break;
+    case "not-ours":
+      console.error(`hivemind graph uninstall: ${status.hint}`);
+      process.exit(1);
+  }
+}
+function parseHistoryArgs(args) {
+  let cwd = process.cwd();
+  let n = 20;
+  let json2 = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "-n" && i + 1 < args.length) {
+      const raw = args[i + 1];
+      if (!/^\d+$/.test(raw)) {
+        console.error("hivemind graph history: -n must be a non-negative integer");
+        process.exit(2);
+      }
+      n = Number(raw);
+      i += 1;
+    } else if (a === "--json") {
+      json2 = true;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph history: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd, n, json: json2 };
+}
+function runHistoryCommand(args) {
+  const opts = parseHistoryArgs(args);
+  const { key: repoKey } = deriveProjectKey(opts.cwd);
+  const baseDir = repoDir(repoKey);
+  const total = countHistoryEntries(baseDir);
+  const entries = readHistoryTail(baseDir, opts.n);
+  if (opts.json) {
+    for (const e of entries)
+      console.log(JSON.stringify(e));
+    return;
+  }
+  if (total === 0) {
+    console.log("No history yet. Run `hivemind graph build` to record one.");
+    return;
+  }
+  console.log(`history.jsonl: ${total} total entries; showing last ${entries.length}`);
+  console.log("");
+  for (const e of entries) {
+    const commit = e.commit_sha === null ? "(no-git)" : e.commit_sha.slice(0, 7);
+    const snap = e.snapshot_sha256.slice(0, 7);
+    console.log(`  ${e.ts}  commit=${commit}  snap=${snap}  nodes=${e.node_count}  edges=${e.edge_count}  trigger=${e.trigger}`);
+  }
+}
+function parseDiffArgs(args) {
+  let cwd = process.cwd();
+  let json2 = false;
+  let limit = 10;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--json") {
+      json2 = true;
+    } else if (a === "--limit" && i + 1 < args.length) {
+      const raw = args[i + 1];
+      if (!/^\d+$/.test(raw)) {
+        console.error("hivemind graph diff: --limit must be a non-negative integer");
+        process.exit(2);
+      }
+      limit = Number(raw);
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else if (a !== void 0 && !a.startsWith("--")) {
+      positional.push(a);
+    } else {
+      console.error(`hivemind graph diff: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  if (positional.length !== 2) {
+    console.error("hivemind graph diff: expected exactly two commit SHAs");
+    console.error(USAGE);
+    process.exit(2);
+  }
+  return { cwd, sha1: positional[0], sha2: positional[1], json: json2, limit };
+}
+function runDiffCommand(args) {
+  const opts = parseDiffArgs(args);
+  const { key: repoKey } = deriveProjectKey(opts.cwd);
+  const baseDir = repoDir(repoKey);
+  const from = loadSnapshotByCommit(baseDir, opts.sha1);
+  if (from === null) {
+    console.error(`hivemind graph diff: snapshot not found for ${opts.sha1}`);
+    console.error(`  expected: ${baseDir}/snapshots/${opts.sha1}.json`);
+    console.error("  hint: run 'hivemind graph build' on the relevant commit, or check the commit sha");
+    process.exit(1);
+  }
+  const to = loadSnapshotByCommit(baseDir, opts.sha2);
+  if (to === null) {
+    console.error(`hivemind graph diff: snapshot not found for ${opts.sha2}`);
+    console.error(`  expected: ${baseDir}/snapshots/${opts.sha2}.json`);
+    process.exit(1);
+  }
+  const diff = diffSnapshots(from, to);
+  if (opts.json) {
+    console.log(JSON.stringify(diff, null, 2));
+    return;
+  }
+  console.log(`Diff: ${opts.sha1} \u2192 ${opts.sha2}`);
+  console.log("");
+  printDiffHuman(diff, opts.limit);
+}
+function parseBuildArgs(args) {
+  let cwd = process.cwd();
+  let trigger = "manual";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--trigger" && i + 1 < args.length) {
+      const v = args[i + 1];
+      if (v === "manual" || v === "session-end" || v === "post-commit" || v === "unknown") {
+        trigger = v;
+      } else {
+        console.error(`hivemind graph build: --trigger must be one of manual|session-end|post-commit|unknown (got '${v}')`);
+        process.exit(2);
+      }
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph build: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd, trigger };
+}
+async function runBuildCommand(args) {
+  const opts = parseBuildArgs(args);
+  const cwd = resolve4(opts.cwd);
+  const { key: repoKey, project } = deriveProjectKey(cwd);
+  const baseDir = repoDir(repoKey);
+  const commitSha = readGitCommit(cwd);
+  const branch = readGitBranch(cwd);
+  const version = getVersion();
+  console.log(`Building codebase graph for ${project}`);
+  console.log(`  repo_key:   ${repoKey}`);
+  console.log(`  commit_sha: ${commitSha ?? "(not in a git repo)"}`);
+  console.log(`  branch:     ${branch ?? "(none / detached)"}`);
+  console.log(`  output:     ${baseDir}`);
+  console.log("");
+  const sourceFiles = discoverSourceFiles(cwd);
+  console.log(`Discovered ${sourceFiles.length} TypeScript source files. Extracting...`);
+  const extractions = [];
+  let skipped = 0;
+  let totalParseErrors = 0;
+  let cacheHits = 0;
+  for (const abs of sourceFiles) {
+    const rel = toForwardSlash(relative(cwd, abs));
+    try {
+      const content = readFileSync20(abs, "utf8");
+      const contentSha = fileContentHash(content);
+      let extraction = readCache(baseDir, contentSha, rel);
+      if (extraction === null) {
+        extraction = extractTypeScript(content, rel);
+        writeCache(baseDir, contentSha, extraction);
+      } else {
+        cacheHits += 1;
+      }
+      if (extraction.parse_errors.length > 0) {
+        totalParseErrors += extraction.parse_errors.length;
+        for (const err of extraction.parse_errors) {
+          console.warn(`  warn: parse issue in ${err.source_file} ${err.location ?? ""}: ${err.message}`);
+        }
+      }
+      extractions.push(extraction);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`  warn: skipping ${rel}: ${msg}`);
+      skipped += 1;
+    }
+  }
+  const metadata = {
+    schema_version: 1,
+    generator: "hivemind-graph",
+    commit_sha: commitSha,
+    repo_key: repoKey
+  };
+  const observation = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    branch,
+    worktree_path: cwd,
+    repo_project: project,
+    generator_version: version,
+    source_files_extracted: extractions.length,
+    source_files_skipped: skipped
+  };
+  const snapshot = buildSnapshot(extractions, metadata, observation);
+  const worktreeId = workTreeIdFor2(cwd);
+  const result = writeSnapshot(snapshot, baseDir, opts.trigger, worktreeId);
+  console.log("");
+  console.log(`Snapshot:      ${result.snapshotPath}`);
+  console.log(`Latest:        ${result.latestCommitPath ?? "(no commit context \u2014 latest-commit.txt not updated)"}`);
+  console.log(`SHA-256:       ${result.snapshotSha256}`);
+  console.log(`Nodes:         ${snapshot.nodes.length}`);
+  console.log(`Edges:         ${snapshot.links.length}`);
+  console.log(`Files extracted: ${extractions.length} (skipped: ${skipped}, parse warnings: ${totalParseErrors}, cache hits: ${cacheHits}/${sourceFiles.length})`);
+  const pushOutcome = await pushSnapshot(snapshot, worktreeId);
+  switch (pushOutcome.kind) {
+    case "inserted":
+      console.log(`Cloud:         pushed to codebase table (commit ${pushOutcome.commitSha.slice(0, 7)})`);
+      break;
+    case "inserted-with-duplicate-race":
+      console.warn(`Cloud:         pushed (commit ${pushOutcome.commitSha.slice(0, 7)}) but ${pushOutcome.rowCount} rows now share`);
+      console.warn(`               this identity key \u2014 a concurrent writer raced. v1.1 adds a server-side`);
+      console.warn(`               UNIQUE constraint; until then, the older row(s) should be deleted manually.`);
+      break;
+    case "already-current":
+      console.log(`Cloud:         already up-to-date (commit ${pushOutcome.commitSha.slice(0, 7)})`);
+      break;
+    case "skipped-no-auth":
+      console.log(`Cloud:         skipped (not authenticated; run \`hivemind login\` to enable cloud sync)`);
+      break;
+    case "skipped-no-commit":
+      console.log(`Cloud:         skipped (no commit context \u2014 not in a git repo)`);
+      break;
+    case "skipped-disabled":
+      console.log(`Cloud:         skipped (HIVEMIND_GRAPH_PUSH=0)`);
+      break;
+    case "drift":
+      console.warn(`Cloud:         DRIFT \u2014 commit ${pushOutcome.commitSha.slice(0, 7)} is in cloud with`);
+      console.warn(`               sha256=${pushOutcome.cloudSha256.slice(0, 12)}... but local rebuild produced`);
+      console.warn(`               sha256=${pushOutcome.localSha256.slice(0, 12)}...`);
+      console.warn(`               (probably extractor version drift; investigate before forcing.)`);
+      break;
+    case "error":
+      console.warn(`Cloud:         push error (non-fatal): ${pushOutcome.message}`);
+      break;
+  }
+}
+function parsePullArgs(args) {
+  let cwd = process.cwd();
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph pull: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd };
+}
+async function runPullCommand(args) {
+  const opts = parsePullArgs(args);
+  const outcome = await pullSnapshot(opts.cwd);
+  switch (outcome.kind) {
+    case "pulled":
+      console.log(`Pulled commit ${outcome.commitSha.slice(0, 7)}`);
+      console.log(`  sha256:  ${outcome.snapshotSha256.slice(0, 12)}...`);
+      console.log(`  bytes:   ${outcome.bytes}`);
+      console.log(`  origin:  worktree_id=${outcome.sourceWorktreePath}`);
+      console.log(`  cloud ts: ${new Date(outcome.cloudTs).toISOString()}`);
+      break;
+    case "up-to-date":
+      console.log(`Already up-to-date (commit ${outcome.commitSha.slice(0, 7)}, sha256 ${outcome.snapshotSha256.slice(0, 12)}...)`);
+      break;
+    case "local-newer":
+      console.log(`Local is newer than cloud \u2014 not pulling.`);
+      console.log(`  commit:   ${outcome.commitSha.slice(0, 7)}`);
+      console.log(`  local ts: ${new Date(outcome.localTs).toISOString()}`);
+      console.log(`  cloud ts: ${new Date(outcome.cloudTs).toISOString()}`);
+      break;
+    case "no-cloud-row":
+      console.log(`No cloud snapshot for commit ${outcome.commitSha.slice(0, 7)} \u2014 run \`hivemind graph build\` to create one.`);
+      break;
+    case "skipped-no-auth":
+      console.log(`Skipped: not authenticated (run \`hivemind login\`).`);
+      break;
+    case "skipped-disabled":
+      console.log(`Skipped: HIVEMIND_GRAPH_PULL=0.`);
+      break;
+    case "skipped-no-head":
+      console.log(`Skipped: not in a git repo (\`git rev-parse HEAD\` failed).`);
+      break;
+    case "error":
+      console.warn(`Pull error (non-fatal): ${outcome.message}`);
+      process.exitCode = 1;
+      break;
+  }
+}
+function workTreeIdFor2(cwd) {
+  return createHash6("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function discoverSourceFiles(rootDir) {
+  const out = [];
+  walk(rootDir, out);
+  out.sort();
+  return out;
+}
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (DEFAULT_IGNORES.has(entry.name))
+      continue;
+    if (entry.name.startsWith("."))
+      continue;
+    const abs = join27(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(abs, out);
+    } else if (entry.isFile() && isSourceFile(entry.name)) {
+      out.push(abs);
+    }
+  }
+}
+function isSourceFile(name) {
+  if (name.endsWith(".d.ts"))
+    return false;
+  return name.endsWith(".ts") || name.endsWith(".tsx");
+}
+function toForwardSlash(p) {
+  return sep === "\\" ? p.replace(/\\/g, "/") : p;
+}
+function readGitCommit(cwd) {
+  try {
+    return execSync3("git rev-parse HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function readGitBranch(cwd) {
+  try {
+    const out = execSync3("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out === "" || out === "HEAD" ? null : out;
+  } catch {
+    return null;
+  }
+}
+
+// dist/src/commands/dashboard.js
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync18 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { dirname as dirname12, join as join35, resolve as resolve5 } from "node:path";
+
+// dist/src/dashboard/data.js
+import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { join as join33 } from "node:path";
+
+// dist/src/notifications/sources/org-stats.js
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname9, join as join28 } from "node:path";
+var log5 = (msg) => log2("notifications-org-stats", msg);
+var FETCH_TIMEOUT_MS = 1500;
+var DEFAULT_API_URL3 = "https://api.deeplake.ai";
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function cacheFilePath() {
+  return join28(homedir11(), ".deeplake", "hivemind-stats-cache.json");
+}
+function cacheScopeKey(creds) {
+  return JSON.stringify({
+    apiUrl: creds.apiUrl ?? DEFAULT_API_URL3,
+    orgId: creds.orgId ?? "",
+    userName: creds.userName ?? ""
+  });
+}
+function scopeFromServer(s) {
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+  return {
+    sessionsCount: n(s?.sessions_count),
+    memoryRecallCount: n(s?.memory_recall_count),
+    memorySearchBytes: n(s?.memory_search_bytes)
+  };
+}
+function readCache2(scopeKey) {
+  if (!existsSync21(cacheFilePath()))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync21(cacheFilePath(), "utf-8"));
+    if (!parsed || typeof parsed !== "object")
+      return {};
+    if (parsed.scopeKey !== scopeKey)
+      return {};
+    if (typeof parsed.fetchedAt !== "number")
+      return {};
+    const age = Date.now() - parsed.fetchedAt;
+    const data = parsed.data;
+    if (!data || typeof data !== "object" || !data.org || !data.user)
+      return {};
+    if (age >= 0 && age < CACHE_TTL_MS)
+      return { fresh: data };
+    return { stale: data };
+  } catch (e) {
+    log5(`cache read failed: ${e?.message ?? String(e)}`);
+    return {};
+  }
+}
+function writeCache2(scopeKey, data) {
+  try {
+    mkdirSync13(dirname9(cacheFilePath()), { recursive: true });
+    const body = { fetchedAt: Date.now(), scopeKey, data };
+    writeFileSync16(cacheFilePath(), JSON.stringify(body), "utf-8");
+  } catch (e) {
+    log5(`cache write failed: ${e?.message ?? String(e)}`);
+  }
+}
+async function fetchOrgStats(creds) {
+  if (!creds?.token)
+    return null;
+  const apiUrl = creds.apiUrl ?? DEFAULT_API_URL3;
+  const scopeKey = cacheScopeKey(creds);
+  const { fresh, stale } = readCache2(scopeKey);
+  if (fresh) {
+    log5("cache hit \u2014 returning fresh org stats");
+    return fresh;
+  }
+  const url = `${apiUrl}/me/hivemind-stats`;
+  const ctrl = new AbortController();
+  const timeoutHandle = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${creds.token}`,
+        ...creds.orgId ? { "X-Activeloop-Org-Id": creds.orgId } : {}
+      },
+      signal: ctrl.signal
+    });
+    if (!resp.ok) {
+      log5(`fetch ${url} returned ${resp.status}`);
+      return stale ?? null;
+    }
+    const body = await resp.json();
+    if (!body || typeof body !== "object") {
+      log5(`fetch ${url} returned malformed body`);
+      return stale ?? null;
+    }
+    const data = {
+      org: scopeFromServer(body.org),
+      user: scopeFromServer(body.user)
+    };
+    writeCache2(scopeKey, data);
+    log5(`fetched org stats from ${apiUrl}`);
+    return data;
+  } catch (e) {
+    log5(`fetch ${url} failed: ${e?.message ?? String(e)}`);
+    return stale ?? null;
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// dist/src/notifications/usage-tracker.js
+import { appendFileSync as appendFileSync3, existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync22, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname10, join as join29 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+var log6 = (msg) => log2("usage-tracker", msg);
+function statsFilePath() {
+  return join29(homedir12(), ".deeplake", "usage-stats.jsonl");
+}
+function readUsageRecords() {
+  try {
+    if (!existsSync22(statsFilePath()))
+      return [];
+    const raw = readFileSync22(statsFilePath(), "utf-8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const rec = JSON.parse(trimmed);
+        if (typeof rec.endedAt === "string" && typeof rec.sessionId === "string") {
+          out.push({
+            endedAt: rec.endedAt,
+            sessionId: rec.sessionId,
+            memorySearchBytes: typeof rec.memorySearchBytes === "number" ? rec.memorySearchBytes : 0,
+            memorySearchCount: typeof rec.memorySearchCount === "number" ? rec.memorySearchCount : 0
+          });
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch (e) {
+    log6(`readUsageRecords failed: ${e?.message ?? String(e)}`);
+    return [];
+  }
+}
+function sumMetric(records, key) {
+  let total = 0;
+  for (const r of records) {
+    const v = r[key];
+    if (typeof v === "number" && Number.isFinite(v))
+      total += v;
+  }
+  return total;
+}
+function countUserGeneratedSkills(userName) {
+  if (!userName)
+    return 0;
+  const dir = join29(homedir12(), ".claude", "skills");
+  if (!existsSync22(dir))
+    return 0;
+  const suffix = `--${userName}`;
+  try {
+    let count = 0;
+    for (const name of readdirSync3(dir)) {
+      const idx = name.lastIndexOf(suffix);
+      if (idx > 0 && idx + suffix.length === name.length)
+        count += 1;
+    }
+    return count;
+  } catch (e) {
+    log6(`countUserGeneratedSkills readdir failed: ${e?.message ?? String(e)}`);
+    return 0;
+  }
 }
 
-// dist/src/commands/skillify.js
-import { readdirSync as readdirSync5, existsSync as existsSync26, readFileSync as readFileSync22, mkdirSync as mkdirSync13, renameSync as renameSync7 } from "node:fs";
-import { homedir as homedir19 } from "node:os";
-import { dirname as dirname8, join as join32 } from "node:path";
-
-// dist/src/skillify/scope-config.js
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join22 } from "node:path";
+// dist/src/skillify/state.js
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync17, writeSync, mkdirSync as mkdirSync15, renameSync as renameSync9, rmdirSync, existsSync as existsSync24, lstatSync as lstatSync3, unlinkSync as unlinkSync9, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { join as join32 } from "node:path";
 
 // dist/src/skillify/legacy-migration.js
-import { existsSync as existsSync15, renameSync as renameSync4 } from "node:fs";
-import { dirname as dirname3, join as join21 } from "node:path";
+import { existsSync as existsSync23, renameSync as renameSync8 } from "node:fs";
+import { dirname as dirname11, join as join31 } from "node:path";
 
 // dist/src/skillify/state-dir.js
-import { homedir as homedir10 } from "node:os";
-import { join as join20 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join30 } from "node:path";
 function getStateDir() {
   const override = process.env.HIVEMIND_STATE_DIR?.trim();
-  return override && override.length > 0 ? override : join20(homedir10(), ".deeplake", "state", "skillify");
+  return override && override.length > 0 ? override : join30(homedir13(), ".deeplake", "state", "skillify");
 }
 
 // dist/src/skillify/legacy-migration.js
@@ -5448,13 +7520,13 @@ function migrateLegacyStateDir() {
     return;
   attempted = true;
   const current = getStateDir();
-  const legacy = join21(dirname3(current), "skilify");
-  if (!existsSync15(legacy))
+  const legacy = join31(dirname11(current), "skilify");
+  if (!existsSync23(legacy))
     return;
-  if (existsSync15(current))
+  if (existsSync23(current))
     return;
   try {
-    renameSync4(legacy, current);
+    renameSync8(legacy, current);
     dlog(`migrated ${legacy} -> ${current}`);
   } catch (err) {
     const code = err.code;
@@ -5466,18 +7538,818 @@ function migrateLegacyStateDir() {
   }
 }
 
+// dist/src/skillify/state.js
+var YIELD_BUF = new Int32Array(new SharedArrayBuffer(4));
+var TRIGGER_THRESHOLD = (() => {
+  const n = Number(process.env.HIVEMIND_SKILLIFY_EVERY_N_TURNS ?? "");
+  return Number.isInteger(n) && n > 0 ? n : 20;
+})();
+
+// dist/src/dashboard/data.js
+var log7 = (msg) => log2("dashboard-data", msg);
+var BYTES_PER_TOKEN = 4;
+var SAVINGS_MULTIPLIER = 1.7;
+function graphsRoot2() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join33(homedir14(), ".hivemind", "graphs");
+}
+function bytesToSavedTokens(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0)
+    return 0;
+  const delivered = bytes / BYTES_PER_TOKEN;
+  return (SAVINGS_MULTIPLIER - 1) * delivered;
+}
+function resolveSnapshot(repoDir2) {
+  const snapshotsDir = join33(repoDir2, "snapshots");
+  if (!existsSync25(snapshotsDir))
+    return null;
+  let snapshotPath = null;
+  const pointer = join33(repoDir2, "latest-commit.txt");
+  if (existsSync25(pointer)) {
+    try {
+      const sha = readFileSync24(pointer, "utf-8").trim();
+      if (sha) {
+        const candidate = join33(snapshotsDir, `${sha}.json`);
+        if (existsSync25(candidate))
+          snapshotPath = candidate;
+        else
+          log7(`latest-commit.txt points at missing ${sha}.json \u2014 scanning snapshots/`);
+      }
+    } catch (e) {
+      log7(`latest-commit.txt read failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (!snapshotPath) {
+    try {
+      const candidates = readdirSync4(snapshotsDir).filter((name) => name.endsWith(".json")).map((name) => {
+        const full = join33(snapshotsDir, name);
+        return { full, mtime: statSync3(full).mtimeMs };
+      }).sort((a, b) => b.mtime - a.mtime);
+      if (candidates.length > 0)
+        snapshotPath = candidates[0].full;
+    } catch (e) {
+      log7(`snapshots/ scan failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (!snapshotPath)
+    return null;
+  let raw;
+  try {
+    raw = readFileSync24(snapshotPath, "utf-8");
+  } catch (e) {
+    log7(`snapshot read failed: ${e?.message ?? String(e)}`);
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    log7(`snapshot parse failed: ${e?.message ?? String(e)}`);
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.nodes) || !Array.isArray(parsed.links)) {
+    log7("snapshot shape invalid (missing nodes/links arrays)");
+    return null;
+  }
+  return {
+    commitSha: parsed.graph?.commit_sha ?? null,
+    snapshotPath,
+    nodeCount: parsed.nodes.length,
+    edgeCount: parsed.links.length,
+    snapshot: parsed
+  };
+}
+async function loadKpis(creds) {
+  const userName = creds?.userName;
+  const skillsCreated = countUserGeneratedSkills(userName);
+  const records = readUsageRecords();
+  const localBytes = sumMetric(records, "memorySearchBytes");
+  const localCount = sumMetric(records, "memorySearchCount");
+  let orgStats = null;
+  if (creds?.token) {
+    try {
+      orgStats = await fetchOrgStats(creds);
+    } catch (e) {
+      log7(`fetchOrgStats threw: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (orgStats) {
+    return {
+      tokensSaved: bytesToSavedTokens(orgStats.org.memorySearchBytes),
+      tokensSource: "org",
+      skillsCreated,
+      memorySearches: orgStats.org.memoryRecallCount,
+      sessionsCount: orgStats.org.sessionsCount,
+      userTokensSaved: bytesToSavedTokens(orgStats.user.memorySearchBytes)
+    };
+  }
+  if (records.length > 0) {
+    return {
+      tokensSaved: bytesToSavedTokens(localBytes),
+      tokensSource: "local",
+      skillsCreated,
+      memorySearches: localCount,
+      sessionsCount: records.length,
+      userTokensSaved: bytesToSavedTokens(localBytes)
+    };
+  }
+  return {
+    tokensSaved: null,
+    tokensSource: "none",
+    skillsCreated,
+    memorySearches: 0,
+    sessionsCount: null,
+    userTokensSaved: null
+  };
+}
+async function loadDashboardData(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { key: repoKey, project: repoProject } = deriveProjectKey(cwd);
+  const repoDir2 = join33(opts.graphsHome ?? graphsRoot2(), repoKey);
+  const graph = resolveSnapshot(repoDir2);
+  const creds = opts.creds === void 0 ? loadCredentials() : opts.creds;
+  const kpis = await loadKpis(creds);
+  return {
+    repoKey,
+    repoProject,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    kpis,
+    graph
+  };
+}
+
+// dist/src/dashboard/open.js
+import { spawn } from "node:child_process";
+import { accessSync, constants as fsConstants, statSync as statSync4 } from "node:fs";
+import { platform as nodePlatform } from "node:os";
+import { delimiter, join as join34 } from "node:path";
+function resolveOpenPlatform() {
+  const p = nodePlatform();
+  if (p === "linux" || p === "darwin" || p === "win32")
+    return p;
+  return null;
+}
+function openCommandFor(p, path) {
+  switch (p) {
+    case "linux":
+      return { command: "xdg-open", args: [path] };
+    case "darwin":
+      return { command: "open", args: [path] };
+    case "win32":
+      return { command: "cmd", args: ["/c", "start", "", path] };
+  }
+}
+function findBinaryOnPath(name) {
+  const PATH = process.env.PATH ?? "";
+  if (!PATH)
+    return null;
+  const isWin = nodePlatform() === "win32";
+  const exts = isWin ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean) : [""];
+  for (const dir of PATH.split(delimiter)) {
+    if (!dir)
+      continue;
+    for (const ext of exts) {
+      const candidate = join34(dir, name + ext);
+      try {
+        const st = statSync4(candidate);
+        if (!st.isFile())
+          continue;
+        if (isWin)
+          return candidate;
+        try {
+          accessSync(candidate, fsConstants.X_OK);
+          return candidate;
+        } catch {
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function openInBrowser(path, opts = {}) {
+  const p = opts.platformOverride === void 0 ? resolveOpenPlatform() : opts.platformOverride;
+  if (!p)
+    return { attempted: false };
+  const { command, args } = openCommandFor(p, path);
+  const exists = opts.binaryExists ?? ((cmd) => findBinaryOnPath(cmd) !== null);
+  if (!exists(command))
+    return { attempted: false };
+  const useSpawn = opts.spawner ?? spawn;
+  try {
+    const child = useSpawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    if (typeof child.unref === "function") {
+      child.unref();
+    }
+    return { attempted: true, command };
+  } catch {
+    return { attempted: false };
+  }
+}
+
+// dist/src/dashboard/render.js
+var VIS_NETWORK_CDN = "https://unpkg.com/vis-network@9.1.9/standalone/umd/vis-network.min.js";
+var KIND_COLORS = {
+  function: "#7aa2f7",
+  // soft blue
+  class: "#bb9af7",
+  // purple
+  method: "#9ece6a",
+  // green
+  interface: "#e0af68",
+  // amber
+  type_alias: "#7dcfff",
+  // cyan
+  enum: "#f7768e",
+  // pink
+  const: "#9d7cd8",
+  // muted purple
+  module: "#565f89"
+  // slate
+};
+var DEFAULT_NODE_COLOR = "#565f89";
+function isObject2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function transformSnapshotToVis(snapshot) {
+  if (!isObject2(snapshot))
+    return { nodes: [], edges: [] };
+  const raw = snapshot;
+  const visNodes = [];
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(raw.nodes)) {
+    for (const n of raw.nodes) {
+      if (!isObject2(n))
+        continue;
+      const node = n;
+      const id = asString(node.id);
+      if (!id)
+        continue;
+      if (ids.has(id))
+        continue;
+      ids.add(id);
+      const label = asString(node.label) ?? id;
+      const kind = asString(node.kind);
+      const sourceFile = asString(node.source_file);
+      const sourceLoc = asString(node.source_location);
+      const titleParts = [];
+      if (kind)
+        titleParts.push(kind);
+      if (sourceFile) {
+        const loc = sourceLoc ? `${sourceFile}:${sourceLoc}` : sourceFile;
+        titleParts.push(loc);
+      }
+      const color = kind && KIND_COLORS[kind] ? KIND_COLORS[kind] : DEFAULT_NODE_COLOR;
+      visNodes.push({
+        id,
+        label,
+        title: titleParts.length > 0 ? titleParts.map(escHtml).join(" \xB7 ") : escHtml(id),
+        group: kind ?? void 0,
+        color: { background: color, border: color }
+      });
+    }
+  }
+  const visEdges = [];
+  if (Array.isArray(raw.links)) {
+    for (const l of raw.links) {
+      if (!isObject2(l))
+        continue;
+      const edge = l;
+      const from = asString(edge.source);
+      const to = asString(edge.target);
+      if (!from || !to)
+        continue;
+      const relation = asString(edge.relation);
+      const confidence = asString(edge.confidence);
+      const titleParts = [];
+      if (relation)
+        titleParts.push(relation);
+      if (confidence)
+        titleParts.push(`[${confidence}]`);
+      visEdges.push({
+        from,
+        to,
+        title: titleParts.length > 0 ? titleParts.map(escHtml).join(" ") : `${escHtml(from)} \u2192 ${escHtml(to)}`
+      });
+    }
+  }
+  return { nodes: visNodes, edges: visEdges };
+}
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function safeJsonForScript(value) {
+  return JSON.stringify(value).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\u0021--").replace(/-->/g, "--\\u003e");
+}
+function formatTokensCompact(n) {
+  if (!Number.isFinite(n) || n <= 0)
+    return "0";
+  if (n < 1e3)
+    return `${Math.round(n)}`;
+  if (n < 1e5)
+    return `${(n / 1e3).toFixed(1)}k`;
+  if (n < 1e6)
+    return `${Math.round(n / 1e3)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function formatInt(n) {
+  if (!Number.isFinite(n))
+    return "0";
+  return Math.round(n).toLocaleString("en-US");
+}
+function renderKpiCards(kpis) {
+  const tokensValue = kpis.tokensSaved == null ? "\u2014" : `~${formatTokensCompact(kpis.tokensSaved)}`;
+  const tokensSub = (() => {
+    if (kpis.tokensSource === "org") {
+      return kpis.userTokensSaved != null ? `Org-wide \xB7 you ~${formatTokensCompact(kpis.userTokensSaved)}` : "Org-wide";
+    }
+    if (kpis.tokensSource === "local")
+      return "Local (this machine)";
+    return "Run a session to start tracking";
+  })();
+  const memoryValue = kpis.memorySearches > 0 ? formatInt(kpis.memorySearches) : kpis.tokensSource === "none" ? "\u2014" : "0";
+  const sessionsValue = kpis.sessionsCount == null ? "\u2014" : formatInt(kpis.sessionsCount);
+  const cards = [
+    {
+      label: "Tokens saved",
+      value: tokensValue,
+      sub: tokensSub
+    },
+    {
+      label: "Skills created",
+      value: formatInt(kpis.skillsCreated),
+      sub: "~/.claude/skills/"
+    },
+    {
+      label: "Memory recalls",
+      value: memoryValue,
+      sub: kpis.tokensSource === "org" ? "Org-wide" : kpis.tokensSource === "local" ? "Local" : ""
+    },
+    {
+      label: "Sessions",
+      value: sessionsValue,
+      sub: kpis.tokensSource === "org" ? "Org-wide" : kpis.tokensSource === "local" ? "Local" : ""
+    }
+  ];
+  return cards.map((c) => `
+        <div class="kpi">
+          <div class="kpi-label">${escHtml(c.label)}</div>
+          <div class="kpi-value">${escHtml(c.value)}</div>
+          <div class="kpi-sub">${escHtml(c.sub)}</div>
+        </div>`).join("");
+}
+function renderGraphSection(data) {
+  if (data.graph == null) {
+    return `
+      <div class="graph-card">
+        <h2>Codebase graph</h2>
+        <div class="empty">
+          No graph snapshot yet for this repo.<br>
+          Run <code>hivemind graph build</code> to generate one.
+        </div>
+      </div>`;
+  }
+  const visPayload = transformSnapshotToVis(data.graph.snapshot);
+  const commitLabel = data.graph.commitSha ? `commit ${data.graph.commitSha.slice(0, 12)}` : "no commit (loose dir)";
+  const meta = `${formatInt(data.graph.nodeCount)} nodes \xB7 ${formatInt(data.graph.edgeCount)} edges \xB7 ${commitLabel}`;
+  return `
+      <div class="graph-card">
+        <h2>Codebase graph</h2>
+        <div class="graph-meta">${escHtml(meta)}</div>
+        <div id="graph"></div>
+      </div>
+      <script type="application/json" id="hm-graph-data">${safeJsonForScript(visPayload)}</script>
+      <script src="${VIS_NETWORK_CDN}"></script>
+      <script>
+        (function () {
+          var holder = document.getElementById('hm-graph-data');
+          var container = document.getElementById('graph');
+          if (!holder || !container || typeof vis === 'undefined') return;
+          var payload;
+          try { payload = JSON.parse(holder.textContent); }
+          catch (e) { container.textContent = 'graph payload parse failed'; return; }
+          if (!payload || !Array.isArray(payload.nodes) || payload.nodes.length === 0) {
+            container.textContent = 'snapshot has no nodes';
+            return;
+          }
+          new vis.Network(container, payload, {
+            nodes: {
+              shape: 'dot',
+              size: 9,
+              font: { color: '#e8eaed', size: 11, face: 'system-ui, sans-serif' },
+              borderWidth: 1,
+            },
+            edges: {
+              color: { color: 'rgba(120, 130, 150, 0.45)', highlight: '#f5b80a', hover: '#e8eaed' },
+              arrows: { to: { enabled: true, scaleFactor: 0.45 } },
+              smooth: { enabled: true, type: 'continuous', roundness: 0.2 },
+              width: 1,
+            },
+            physics: {
+              stabilization: { iterations: 120 },
+              barnesHut: { gravitationalConstant: -2200, springLength: 80, springConstant: 0.04 },
+            },
+            interaction: { hover: true, dragNodes: true, tooltipDelay: 120 },
+          });
+        }());
+      </script>`;
+}
+var STYLES = `
+        :root {
+          color-scheme: dark;
+          --bg: #0b0d10;
+          --fg: #e8eaed;
+          --muted: #8b9099;
+          --accent: #f5b80a;
+          --card: #15181d;
+          --border: #22272e;
+        }
+        * { box-sizing: border-box; }
+        html, body { margin: 0; padding: 0; }
+        body {
+          font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+          background: var(--bg);
+          color: var(--fg);
+          padding: 24px;
+        }
+        .header { display: flex; justify-content: space-between; align-items: baseline; margin-bottom: 24px; gap: 16px; flex-wrap: wrap; }
+        .brand { font-weight: 600; font-size: 18px; }
+        .brand .bee { color: var(--accent); margin-right: 4px; }
+        .brand .repo { color: var(--muted); font-weight: 400; margin-left: 8px; }
+        .header .ts { color: var(--muted); font-size: 12px; }
+        .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 16px; margin-bottom: 32px; }
+        .kpi { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px 20px; }
+        .kpi-label { color: var(--muted); font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; }
+        .kpi-value { font-size: 28px; font-weight: 600; margin-top: 6px; line-height: 1.1; }
+        .kpi-sub { color: var(--muted); font-size: 12px; margin-top: 4px; }
+        .graph-card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px; }
+        .graph-card h2 { margin: 0 0 8px; font-size: 15px; font-weight: 500; }
+        .graph-meta { color: var(--muted); font-size: 12px; margin-bottom: 12px; }
+        #graph { height: 70vh; border: 1px solid var(--border); border-radius: 4px; background: #0e1116; }
+        .empty { padding: 48px 16px; text-align: center; color: var(--muted); }
+        .empty code { background: #1c2128; padding: 2px 6px; border-radius: 3px; color: var(--fg); font-family: ui-monospace, "SFMono-Regular", monospace; }
+        .footer { color: var(--muted); font-size: 11px; margin-top: 24px; text-align: right; }
+`;
+function renderDashboardHtml(data) {
+  const title = `Hivemind Dashboard \xB7 ${data.repoProject}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${escHtml(title)}</title>
+    <style>${STYLES}</style>
+  </head>
+  <body>
+    <div class="header">
+      <div class="brand">
+        <span class="bee">\u{1F41D}</span>hivemind dashboard
+        <span class="repo">/ ${escHtml(data.repoProject)}</span>
+      </div>
+      <div class="ts">${escHtml(data.generatedAt)}</div>
+    </div>
+    <div class="kpi-grid">${renderKpiCards(data.kpis)}
+    </div>
+    ${renderGraphSection(data)}
+    <div class="footer">repo_key ${escHtml(data.repoKey)}</div>
+  </body>
+</html>
+`;
+}
+
+// dist/src/dashboard/serve.js
+import { createServer } from "node:http";
+var DEFAULT_PORT = 8123;
+var DEFAULT_HOST = "127.0.0.1";
+function handleRequest(html) {
+  return (req, res) => {
+    const url = req.url ?? "/";
+    const path = url.split("?")[0];
+    if (req.method === "GET" && (path === "/" || path === "/index.html")) {
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.setHeader("Cache-Control", "no-store");
+      res.end(html);
+      return;
+    }
+    if (req.method === "GET" && path === "/health") {
+      res.statusCode = 204;
+      res.end();
+      return;
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Not found. The dashboard lives at /.\n");
+  };
+}
+function tryListen(server, host, port) {
+  return new Promise((resolve6, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("server bound to a non-IP address"));
+        return;
+      }
+      resolve6(addr.port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+async function serveDashboardHtml(opts) {
+  const host = opts.host ?? DEFAULT_HOST;
+  const requested = opts.port === void 0 || !Number.isFinite(opts.port) || opts.port < 0 ? DEFAULT_PORT : opts.port;
+  const server = createServer(handleRequest(opts.html));
+  let bound;
+  try {
+    bound = await tryListen(server, host, requested);
+  } catch (e) {
+    if (e?.code !== "EADDRINUSE")
+      throw e;
+    const fallback = createServer(handleRequest(opts.html));
+    bound = await tryListen(fallback, host, 0);
+    server.removeAllListeners();
+    return makeHandle(fallback, host, bound);
+  }
+  return makeHandle(server, host, bound);
+}
+function makeHandle(server, host, port) {
+  let resolveStopped;
+  const stopped = new Promise((resolve6) => {
+    resolveStopped = resolve6;
+  });
+  server.on("close", () => resolveStopped());
+  return {
+    host,
+    port,
+    stopped,
+    close: () => new Promise((resolve6, reject) => {
+      server.close((err) => err ? reject(err) : resolve6());
+    })
+  };
+}
+
+// dist/src/commands/dashboard.js
+var USAGE2 = `hivemind dashboard \u2014 codebase graph + KPI dashboard (HTML)
+
+Usage:
+  hivemind dashboard [--cwd <path>] [--out <path>] [--no-open]
+                     [--serve] [--port <n>]
+      Build a self-contained HTML dashboard for this repo, write it
+      to disk, and either open it in the default browser or serve
+      it over loopback HTTP for headless / SSH workflows.
+
+      --cwd <path>   Use a different project root (defaults to cwd).
+      --out <path>   Write to a custom path (defaults to
+                     ~/.hivemind/dashboards/<repo-key>/index.html).
+      --no-open      Don't open the browser. Combine with --serve
+                     to start the server without auto-launching.
+      --serve        Start a loopback HTTP server (127.0.0.1) so the
+                     dashboard is reachable at a URL. Stays alive
+                     until Ctrl+C. Ideal for VS Code / Cursor
+                     Remote-SSH (auto-forwards the port \u2192 click to
+                     open in the integrated browser tab).
+      --port <n>     Port for --serve (default 8123). Falls back to
+                     a kernel-assigned port if <n> is in use.
+
+  hivemind dashboard --help
+      Show this message.
+
+Data sources (all read-only):
+  - Graph snapshot at ~/.hivemind/graphs/<repo-key>/   (produced by
+    \`hivemind graph build\`; the dashboard works without it and shows
+    an empty-state until the producer has run)
+  - KPIs via the org stats endpoint (cached) with a local fallback
+    to ~/.deeplake/usage-stats.jsonl
+  - Skills created from ~/.claude/skills/<name>--<author>/ directories
+`;
+function parsePort(raw) {
+  if (raw === void 0 || raw === "")
+    return { error: "--port requires a value" };
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0 || n > 65535) {
+    return { error: `--port must be an integer in [0, 65535], got '${raw}'` };
+  }
+  return n;
+}
+function parseDashboardArgs(args) {
+  let cwd;
+  let outPath = "";
+  let open = true;
+  let serve = false;
+  let port;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--help" || a === "-h")
+      return { help: true };
+    if (a === "--no-open") {
+      open = false;
+      continue;
+    }
+    if (a === "--serve") {
+      serve = true;
+      continue;
+    }
+    if (a === "--cwd") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--cwd requires a value" };
+      }
+      cwd = v;
+      continue;
+    }
+    if (a.startsWith("--cwd=")) {
+      cwd = a.slice("--cwd=".length);
+      continue;
+    }
+    if (a === "--out") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--out requires a value" };
+      }
+      outPath = v;
+      continue;
+    }
+    if (a.startsWith("--out=")) {
+      outPath = a.slice("--out=".length);
+      continue;
+    }
+    if (a === "--port") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--port requires a value" };
+      }
+      const parsed = parsePort(v);
+      if (typeof parsed === "object")
+        return { error: parsed.error };
+      port = parsed;
+      continue;
+    }
+    if (a.startsWith("--port=")) {
+      const parsed = parsePort(a.slice("--port=".length));
+      if (typeof parsed === "object")
+        return { error: parsed.error };
+      port = parsed;
+      continue;
+    }
+    return { error: `unknown arg '${a}'` };
+  }
+  if (port !== void 0 && !serve) {
+    return { error: "--port requires --serve" };
+  }
+  return {
+    args: {
+      cwd: cwd ?? process.cwd(),
+      outPath,
+      open,
+      serve,
+      port
+    }
+  };
+}
+function defaultDashboardOutPath(repoKey) {
+  return join35(homedir15(), ".hivemind", "dashboards", repoKey, "index.html");
+}
+async function runDashboardCommand(rawArgs, runOpts = {}) {
+  const out = runOpts.out ?? ((s) => {
+    process.stdout.write(s);
+  });
+  const err = runOpts.err ?? ((s) => {
+    process.stderr.write(s);
+  });
+  const opener = runOpts.opener ?? openInBrowser;
+  const parsed = parseDashboardArgs(rawArgs);
+  if (parsed.help) {
+    out(USAGE2);
+    return 0;
+  }
+  if (parsed.error || !parsed.args) {
+    err(`hivemind dashboard: ${parsed.error ?? "invalid arguments"}
+`);
+    err(USAGE2);
+    return 2;
+  }
+  const { cwd, outPath, open } = parsed.args;
+  let data;
+  try {
+    data = await loadDashboardData({ cwd });
+  } catch (e) {
+    err(`hivemind dashboard: failed to load data: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  const html = renderDashboardHtml(data);
+  const finalOut = outPath || defaultDashboardOutPath(data.repoKey);
+  const absOut = resolve5(finalOut);
+  try {
+    mkdirSync16(dirname12(absOut), { recursive: true });
+    writeFileSync18(absOut, html, "utf-8");
+  } catch (e) {
+    err(`hivemind dashboard: failed to write ${absOut}: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  out(`Wrote ${absOut}
+`);
+  if (data.graph == null) {
+    out(`(no codebase graph yet \u2014 run 'hivemind graph build' to populate)
+`);
+  }
+  if (parsed.args.serve) {
+    return await runServeLoop(html, parsed.args, runOpts, out, err);
+  }
+  if (open) {
+    const result = opener(absOut);
+    if (result.attempted) {
+      out(`Opening via ${result.command}
+`);
+    } else {
+      out(`(no opener for this platform; open the file above manually)
+`);
+    }
+  }
+  return 0;
+}
+async function runServeLoop(html, args, runOpts, out, err) {
+  const server = runOpts.server ?? serveDashboardHtml;
+  const opener = runOpts.opener ?? openInBrowser;
+  const onSignal = runOpts.onSignal ?? defaultOnSignal;
+  let handle;
+  try {
+    handle = await server({ html, port: args.port });
+  } catch (e) {
+    err(`hivemind dashboard: failed to start server: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  const url = `http://${handle.host}:${handle.port}/`;
+  out(`Serving dashboard at ${url}  (Ctrl+C to stop)
+`);
+  if (args.open) {
+    const result = opener(url);
+    if (result.attempted) {
+      out(`Opening via ${result.command}
+`);
+    } else {
+      out(`(no opener for this platform; click the URL above or open it manually)
+`);
+    }
+  }
+  let resolveDone;
+  const done = new Promise((r) => {
+    resolveDone = r;
+  });
+  const shutdown = async () => {
+    try {
+      await handle.close();
+    } catch {
+    }
+    resolveDone(0);
+  };
+  const offInt = onSignal("SIGINT", shutdown);
+  const offTerm = onSignal("SIGTERM", shutdown);
+  handle.stopped.then(() => resolveDone(0));
+  try {
+    return await done;
+  } finally {
+    offInt();
+    offTerm();
+  }
+}
+function defaultOnSignal(signal, handler) {
+  process.on(signal, handler);
+  return () => process.off(signal, handler);
+}
+
+// dist/src/commands/skillify.js
+import { readdirSync as readdirSync8, existsSync as existsSync36, readFileSync as readFileSync32, mkdirSync as mkdirSync23, renameSync as renameSync12 } from "node:fs";
+import { homedir as homedir24 } from "node:os";
+import { dirname as dirname17, join as join46 } from "node:path";
+
 // dist/src/skillify/scope-config.js
+import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join36 } from "node:path";
 function configPath() {
-  return join22(getStateDir(), "config.json");
+  return join36(getStateDir(), "config.json");
 }
 var DEFAULT = { scope: "me", team: [], install: "project" };
 function loadScopeConfig() {
   migrateLegacyStateDir();
   const CONFIG_PATH2 = configPath();
-  if (!existsSync16(CONFIG_PATH2))
+  if (!existsSync26(CONFIG_PATH2))
     return DEFAULT;
   try {
-    const raw = JSON.parse(readFileSync15(CONFIG_PATH2, "utf-8"));
+    const raw = JSON.parse(readFileSync25(CONFIG_PATH2, "utf-8"));
     const scope = raw.scope === "team" ? "team" : raw.scope === "org" ? "team" : "me";
     const team = Array.isArray(raw.team) ? raw.team.filter((s) => typeof s === "string") : [];
     const install = raw.install === "global" ? "global" : "project";
@@ -5488,19 +8360,19 @@ function loadScopeConfig() {
 }
 function saveScopeConfig(cfg) {
   migrateLegacyStateDir();
-  mkdirSync7(getStateDir(), { recursive: true });
-  writeFileSync11(configPath(), JSON.stringify(cfg, null, 2));
+  mkdirSync17(getStateDir(), { recursive: true });
+  writeFileSync19(configPath(), JSON.stringify(cfg, null, 2));
 }
 
 // dist/src/skillify/pull.js
-import { existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, renameSync as renameSync6, lstatSync as lstatSync4, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync9 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname5, join as join26 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync22, mkdirSync as mkdirSync20, renameSync as renameSync11, lstatSync as lstatSync5, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync11 } from "node:fs";
+import { homedir as homedir18 } from "node:os";
+import { dirname as dirname14, join as join40 } from "node:path";
 
 // dist/src/skillify/skill-writer.js
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync20 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { join as join37 } from "node:path";
 function assertValidSkillName(name) {
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`invalid skill name: empty or non-string`);
@@ -5516,10 +8388,10 @@ function assertValidSkillName(name) {
   }
 }
 function skillDir(skillsRoot, name) {
-  return join23(skillsRoot, name);
+  return join37(skillsRoot, name);
 }
 function skillPath(skillsRoot, name) {
-  return join23(skillDir(skillsRoot, name), "SKILL.md");
+  return join37(skillDir(skillsRoot, name), "SKILL.md");
 }
 function renderFrontmatter(fm) {
   const lines = ["---"];
@@ -5597,10 +8469,10 @@ function writeNewSkill(args) {
   assertValidSkillName(args.name);
   const dir = skillDir(args.skillsRoot, args.name);
   const path = skillPath(args.skillsRoot, args.name);
-  if (existsSync17(path)) {
+  if (existsSync27(path)) {
     throw new Error(`skill already exists at ${path}; use mergeSkill`);
   }
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync18(dir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const author = args.author && args.author.length > 0 ? args.author : void 0;
   const contributors = author ? [author] : [];
@@ -5620,7 +8492,7 @@ function writeNewSkill(args) {
 
 ${args.body.trim()}
 `;
-  writeFileSync12(path, text);
+  writeFileSync20(path, text);
   return {
     path,
     action: "created",
@@ -5632,40 +8504,40 @@ ${args.body.trim()}
   };
 }
 function listSkills(skillsRoot) {
-  if (!existsSync17(skillsRoot))
+  if (!existsSync27(skillsRoot))
     return [];
   const out = [];
-  for (const name of readdirSync2(skillsRoot)) {
-    const skillFile = join23(skillsRoot, name, "SKILL.md");
-    if (existsSync17(skillFile) && statSync3(skillFile).isFile()) {
-      out.push({ name, body: readFileSync16(skillFile, "utf-8") });
+  for (const name of readdirSync5(skillsRoot)) {
+    const skillFile = join37(skillsRoot, name, "SKILL.md");
+    if (existsSync27(skillFile) && statSync5(skillFile).isFile()) {
+      out.push({ name, body: readFileSync26(skillFile, "utf-8") });
     }
   }
   return out;
 }
 function resolveSkillsRoot(install, cwd) {
   if (install === "global") {
-    return join23(homedir11(), ".claude", "skills");
+    return join37(homedir16(), ".claude", "skills");
   }
-  return join23(cwd, ".claude", "skills");
+  return join37(cwd, ".claude", "skills");
 }
 
 // dist/src/skillify/manifest.js
-import { existsSync as existsSync18, lstatSync as lstatSync3, mkdirSync as mkdirSync9, readFileSync as readFileSync17, renameSync as renameSync5, unlinkSync as unlinkSync8, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname4, join as join24 } from "node:path";
+import { existsSync as existsSync28, lstatSync as lstatSync4, mkdirSync as mkdirSync19, readFileSync as readFileSync27, renameSync as renameSync10, unlinkSync as unlinkSync10, writeFileSync as writeFileSync21 } from "node:fs";
+import { dirname as dirname13, join as join38 } from "node:path";
 function emptyManifest() {
   return { version: 1, entries: [] };
 }
 function manifestPath() {
-  return join24(getStateDir(), "pulled.json");
+  return join38(getStateDir(), "pulled.json");
 }
 function loadManifest(path = manifestPath()) {
   migrateLegacyStateDir();
-  if (!existsSync18(path))
+  if (!existsSync28(path))
     return emptyManifest();
   let raw;
   try {
-    raw = readFileSync17(path, "utf-8");
+    raw = readFileSync27(path, "utf-8");
   } catch {
     return emptyManifest();
   }
@@ -5712,10 +8584,10 @@ function loadManifest(path = manifestPath()) {
 }
 function saveManifest(m, path = manifestPath()) {
   migrateLegacyStateDir();
-  mkdirSync9(dirname4(path), { recursive: true });
+  mkdirSync19(dirname13(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  writeFileSync13(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
-  renameSync5(tmp, path);
+  writeFileSync21(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  renameSync10(tmp, path);
 }
 function recordPull(entry, path = manifestPath()) {
   const m = loadManifest(path);
@@ -5740,14 +8612,14 @@ function unlinkSymlinks(paths) {
   for (const path of paths) {
     let st;
     try {
-      st = lstatSync3(path);
+      st = lstatSync4(path);
     } catch {
       continue;
     }
     if (!st.isSymbolicLink())
       continue;
     try {
-      unlinkSync8(path);
+      unlinkSync10(path);
     } catch {
     }
   }
@@ -5757,7 +8629,7 @@ function pruneOrphanedEntries(path = manifestPath()) {
   const live = [];
   let pruned = 0;
   for (const e of m.entries) {
-    if (existsSync18(join24(e.installRoot, e.dirName))) {
+    if (existsSync28(join38(e.installRoot, e.dirName))) {
       live.push(e);
       continue;
     }
@@ -5770,26 +8642,26 @@ function pruneOrphanedEntries(path = manifestPath()) {
 }
 
 // dist/src/skillify/agent-roots.js
-import { existsSync as existsSync19 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { homedir as homedir17 } from "node:os";
+import { join as join39 } from "node:path";
 function resolveDetected(home) {
   const out = [];
-  const codexInstalled = existsSync19(join25(home, ".codex"));
-  const piInstalled = existsSync19(join25(home, ".pi", "agent"));
-  const hermesInstalled = existsSync19(join25(home, ".hermes"));
+  const codexInstalled = existsSync29(join39(home, ".codex"));
+  const piInstalled = existsSync29(join39(home, ".pi", "agent"));
+  const hermesInstalled = existsSync29(join39(home, ".hermes"));
   if (codexInstalled || piInstalled) {
-    out.push(join25(home, ".agents", "skills"));
+    out.push(join39(home, ".agents", "skills"));
   }
   if (hermesInstalled) {
-    out.push(join25(home, ".hermes", "skills"));
+    out.push(join39(home, ".hermes", "skills"));
   }
   if (piInstalled) {
-    out.push(join25(home, ".pi", "agent", "skills"));
+    out.push(join39(home, ".pi", "agent", "skills"));
   }
   return out;
 }
-function detectAgentSkillsRoots(canonicalRoot, home = homedir12()) {
+function detectAgentSkillsRoots(canonicalRoot, home = homedir17()) {
   return resolveDetected(home).filter((p) => p !== canonicalRoot);
 }
 
@@ -5833,18 +8705,18 @@ function isMissingTableError(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join26(homedir13(), ".claude", "skills");
+    return join40(homedir18(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join26(cwd, ".claude", "skills");
+  return join40(cwd, ".claude", "skills");
 }
 function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
   const out = [];
   for (const root of agentRoots) {
-    const link = join26(root, dirName);
+    const link = join40(root, dirName);
     let existing;
     try {
-      existing = lstatSync4(link);
+      existing = lstatSync5(link);
     } catch {
       existing = null;
     }
@@ -5863,13 +8735,13 @@ function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
         continue;
       }
       try {
-        unlinkSync9(link);
+        unlinkSync11(link);
       } catch {
         continue;
       }
     }
     try {
-      mkdirSync10(dirname5(link), { recursive: true });
+      mkdirSync20(dirname14(link), { recursive: true });
       symlinkSync2(canonicalDir, link, "dir");
       out.push(link);
     } catch {
@@ -5884,8 +8756,8 @@ function backfillSymlinks(installRoot) {
     return;
   const detected = detectAgentSkillsRoots(installRoot);
   for (const entry of entries) {
-    const canonical = join26(entry.installRoot, entry.dirName);
-    if (!existsSync20(canonical))
+    const canonical = join40(entry.installRoot, entry.dirName);
+    if (!existsSync30(canonical))
       continue;
     const fresh = fanOutSymlinks(canonical, entry.dirName, detected);
     if (sameSorted(fresh, entry.symlinks))
@@ -5995,10 +8867,10 @@ function renderFrontmatter2(fm) {
   return lines.join("\n");
 }
 function readLocalVersion(path) {
-  if (!existsSync20(path))
+  if (!existsSync30(path))
     return null;
   try {
-    const text = readFileSync18(path, "utf-8");
+    const text = readFileSync28(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -6093,8 +8965,8 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const skillDir2 = join26(root, dirName);
-    const skillFile = join26(skillDir2, "SKILL.md");
+    const skillDir2 = join40(root, dirName);
+    const skillFile = join40(skillDir2, "SKILL.md");
     const remoteVersion = Number(row.version ?? 1);
     const localVersion = readLocalVersion(skillFile);
     const action = decideAction({
@@ -6105,14 +8977,14 @@ async function runPull(opts) {
     });
     let manifestError;
     if (action === "wrote") {
-      mkdirSync10(skillDir2, { recursive: true });
-      if (existsSync20(skillFile)) {
+      mkdirSync20(skillDir2, { recursive: true });
+      if (existsSync30(skillFile)) {
         try {
-          renameSync6(skillFile, `${skillFile}.bak`);
+          renameSync11(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync14(skillFile, renderSkillFile(row));
+      writeFileSync22(skillFile, renderSkillFile(row));
       const symlinks = opts.install === "global" ? fanOutSymlinks(skillDir2, dirName, detectAgentSkillsRoots(root)) : [];
       try {
         recordPull({
@@ -6154,15 +9026,15 @@ async function runPull(opts) {
 }
 
 // dist/src/skillify/unpull.js
-import { existsSync as existsSync21, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync31, readdirSync as readdirSync6, rmSync as rmSync5, statSync as statSync6 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import { join as join41 } from "node:path";
 function resolveUnpullRoot(install, cwd) {
   if (install === "global")
-    return join27(homedir14(), ".claude", "skills");
+    return join41(homedir19(), ".claude", "skills");
   if (!cwd)
     throw new Error("cwd required when install === 'project'");
-  return join27(cwd, ".claude", "skills");
+  return join41(cwd, ".claude", "skills");
 }
 function runUnpull(opts) {
   const root = resolveUnpullRoot(opts.install, opts.cwd);
@@ -6185,8 +9057,8 @@ function runUnpull(opts) {
   const entries = entriesForRoot(manifest, opts.install, root);
   for (const entry of entries) {
     summary.scanned++;
-    const path = join27(root, entry.dirName);
-    if (!existsSync21(path)) {
+    const path = join41(root, entry.dirName);
+    if (!existsSync31(path)) {
       if (!opts.dryRun) {
         unlinkSymlinks(entry.symlinks);
         removePullEntry(opts.install, entry.installRoot, entry.dirName);
@@ -6239,15 +9111,15 @@ function runUnpull(opts) {
     }
     summary.entries.push(result);
   }
-  if (existsSync21(root) && (opts.all || opts.legacyCleanup)) {
+  if (existsSync31(root) && (opts.all || opts.legacyCleanup)) {
     const manifestDirNames = new Set(entries.map((e) => e.dirName));
-    for (const dirName of readdirSync3(root)) {
+    for (const dirName of readdirSync6(root)) {
       if (manifestDirNames.has(dirName))
         continue;
-      const path = join27(root, dirName);
+      const path = join41(root, dirName);
       let st;
       try {
-        st = statSync4(path);
+        st = statSync6(path);
       } catch {
         continue;
       }
@@ -6322,31 +9194,31 @@ function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
 }
 
 // dist/src/commands/mine-local.js
-import { spawn } from "node:child_process";
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { basename, dirname as dirname7, join as join31 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, writeFileSync as writeFileSync24 } from "node:fs";
+import { homedir as homedir23 } from "node:os";
+import { basename as basename2, dirname as dirname16, join as join45 } from "node:path";
 
 // dist/src/skillify/local-source.js
-import { readdirSync as readdirSync4, readFileSync as readFileSync19, existsSync as existsSync22, statSync as statSync5 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { join as join28 } from "node:path";
-var HOME2 = homedir15();
+import { readdirSync as readdirSync7, readFileSync as readFileSync29, existsSync as existsSync32, statSync as statSync7 } from "node:fs";
+import { homedir as homedir20 } from "node:os";
+import { join as join42 } from "node:path";
+var HOME2 = homedir20();
 function encodeCwdClaudeCode(cwd) {
   return cwd.replace(/[/_]/g, "-");
 }
 function detectInstalledAgents() {
   const installs = [];
-  const claudeRoot = join28(HOME2, ".claude", "projects");
-  if (existsSync22(claudeRoot)) {
+  const claudeRoot = join42(HOME2, ".claude", "projects");
+  if (existsSync32(claudeRoot)) {
     installs.push({
       agent: "claude_code",
       sessionRoot: claudeRoot,
       encodeCwd: encodeCwdClaudeCode
     });
   }
-  const codexRoot = join28(HOME2, ".codex", "sessions");
-  if (existsSync22(codexRoot)) {
+  const codexRoot = join42(HOME2, ".codex", "sessions");
+  if (existsSync32(codexRoot)) {
     installs.push({
       agent: "codex",
       sessionRoot: codexRoot,
@@ -6368,14 +9240,14 @@ function listLocalSessions(installs, cwd) {
     const cwdEncoded = install.encodeCwd(cwd);
     let subdirs = [];
     try {
-      subdirs = readdirSync4(install.sessionRoot);
+      subdirs = readdirSync7(install.sessionRoot);
     } catch {
       continue;
     }
     for (const sub of subdirs) {
-      const subdirPath = join28(install.sessionRoot, sub);
+      const subdirPath = join42(install.sessionRoot, sub);
       try {
-        if (!statSync5(subdirPath).isDirectory())
+        if (!statSync7(subdirPath).isDirectory())
           continue;
       } catch {
         continue;
@@ -6383,17 +9255,17 @@ function listLocalSessions(installs, cwd) {
       const inCwd = sub === cwdEncoded;
       let files = [];
       try {
-        files = readdirSync4(subdirPath);
+        files = readdirSync7(subdirPath);
       } catch {
         continue;
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const fullPath = join28(subdirPath, f);
+        const fullPath = join42(subdirPath, f);
         let stats;
         try {
-          stats = statSync5(fullPath);
+          stats = statSync7(fullPath);
         } catch {
           continue;
         }
@@ -6451,7 +9323,7 @@ function pickSessions(candidates, opts) {
 function nativeJsonlToRows(filePath, sessionId, agent) {
   let raw;
   try {
-    raw = readFileSync19(filePath, "utf-8");
+    raw = readFileSync29(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -6541,22 +9413,22 @@ function extractPairs(rows) {
 }
 
 // dist/src/skillify/gate-runner.js
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir16 } from "node:os";
-import { join as join29 } from "node:path";
+import { homedir as homedir21 } from "node:os";
+import { join as join43 } from "node:path";
 var requireForCp = createRequire(import.meta.url);
 var { execFileSync: runChildProcess } = requireForCp("node:child_process");
 var inheritedEnv = process;
 function firstExistingPath(candidates) {
   for (const c of candidates) {
-    if (existsSync23(c))
+    if (existsSync33(c))
       return c;
   }
   return null;
 }
 function findAgentBin(agent) {
-  const home = homedir16();
+  const home = homedir21();
   switch (agent) {
     // /usr/bin/<name> is included in every candidate list — that's the
     // common Linux package-manager install path (apt, dnf, pacman). Old
@@ -6565,45 +9437,45 @@ function findAgentBin(agent) {
     // #170 caught the gap.
     case "claude_code":
       return firstExistingPath([
-        join29(home, ".claude", "local", "claude"),
+        join43(home, ".claude", "local", "claude"),
         "/usr/local/bin/claude",
         "/usr/bin/claude",
-        join29(home, ".npm-global", "bin", "claude"),
-        join29(home, ".local", "bin", "claude"),
+        join43(home, ".npm-global", "bin", "claude"),
+        join43(home, ".local", "bin", "claude"),
         "/opt/homebrew/bin/claude"
-      ]) ?? join29(home, ".claude", "local", "claude");
+      ]) ?? join43(home, ".claude", "local", "claude");
     case "codex":
       return firstExistingPath([
         "/usr/local/bin/codex",
         "/usr/bin/codex",
-        join29(home, ".npm-global", "bin", "codex"),
-        join29(home, ".local", "bin", "codex"),
+        join43(home, ".npm-global", "bin", "codex"),
+        join43(home, ".local", "bin", "codex"),
         "/opt/homebrew/bin/codex"
       ]) ?? "/usr/local/bin/codex";
     case "cursor":
       return firstExistingPath([
         "/usr/local/bin/cursor-agent",
         "/usr/bin/cursor-agent",
-        join29(home, ".npm-global", "bin", "cursor-agent"),
-        join29(home, ".local", "bin", "cursor-agent"),
+        join43(home, ".npm-global", "bin", "cursor-agent"),
+        join43(home, ".local", "bin", "cursor-agent"),
         "/opt/homebrew/bin/cursor-agent"
       ]) ?? "/usr/local/bin/cursor-agent";
     case "hermes":
       return firstExistingPath([
-        join29(home, ".local", "bin", "hermes"),
+        join43(home, ".local", "bin", "hermes"),
         "/usr/local/bin/hermes",
         "/usr/bin/hermes",
-        join29(home, ".npm-global", "bin", "hermes"),
+        join43(home, ".npm-global", "bin", "hermes"),
         "/opt/homebrew/bin/hermes"
-      ]) ?? join29(home, ".local", "bin", "hermes");
+      ]) ?? join43(home, ".local", "bin", "hermes");
     case "pi":
       return firstExistingPath([
-        join29(home, ".local", "bin", "pi"),
+        join43(home, ".local", "bin", "pi"),
         "/usr/local/bin/pi",
         "/usr/bin/pi",
-        join29(home, ".npm-global", "bin", "pi"),
+        join43(home, ".npm-global", "bin", "pi"),
         "/opt/homebrew/bin/pi"
-      ]) ?? join29(home, ".local", "bin", "pi");
+      ]) ?? join43(home, ".local", "bin", "pi");
   }
 }
 
@@ -6633,28 +9505,28 @@ function extractJsonBlock(s) {
 }
 
 // dist/src/skillify/local-manifest.js
-import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname6, join as join30 } from "node:path";
-var LOCAL_MANIFEST_PATH = join30(homedir17(), ".claude", "hivemind", "local-mined.json");
-var LOCAL_MINE_LOCK_PATH = join30(homedir17(), ".claude", "hivemind", "local-mined.lock");
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync23 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { dirname as dirname15, join as join44 } from "node:path";
+var LOCAL_MANIFEST_PATH = join44(homedir22(), ".claude", "hivemind", "local-mined.json");
+var LOCAL_MINE_LOCK_PATH = join44(homedir22(), ".claude", "hivemind", "local-mined.lock");
 function readLocalManifest(path = LOCAL_MANIFEST_PATH) {
-  if (!existsSync24(path))
+  if (!existsSync34(path))
     return null;
   try {
-    return JSON.parse(readFileSync20(path, "utf-8"));
+    return JSON.parse(readFileSync30(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLocalManifest(m, path = LOCAL_MANIFEST_PATH) {
-  mkdirSync11(dirname6(path), { recursive: true });
-  writeFileSync15(path, JSON.stringify(m, null, 2));
+  mkdirSync21(dirname15(path), { recursive: true });
+  writeFileSync23(path, JSON.stringify(m, null, 2));
 }
 var LATEST_RUN_WINDOW_MS = 5 * 60 * 1e3;
 
 // dist/src/commands/mine-local.js
-import { unlinkSync as unlinkSync10 } from "node:fs";
+import { unlinkSync as unlinkSync12 } from "node:fs";
 var EPSILON = 0.3;
 var DEFAULT_N = 8;
 var PAIR_CHAR_CAP = 4e3;
@@ -6665,9 +9537,9 @@ var IN_FLIGHT_MAX_AGE_MS = 6e4;
 var GATE_TIMEOUT_MS = 24e4;
 var MANIFEST_PATH = LOCAL_MANIFEST_PATH;
 function runGateViaStdin(opts) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve6) => {
     if (opts.agent !== "claude_code") {
-      resolve2({
+      resolve6({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6675,8 +9547,8 @@ function runGateViaStdin(opts) {
       });
       return;
     }
-    if (!existsSync25(opts.bin)) {
-      resolve2({
+    if (!existsSync35(opts.bin)) {
+      resolve6({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6692,7 +9564,7 @@ function runGateViaStdin(opts) {
       "--permission-mode",
       "bypassPermissions"
     ];
-    const child = spawn(opts.bin, args, {
+    const child = spawn2(opts.bin, args, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, HIVEMIND_WIKI_WORKER: "1", HIVEMIND_CAPTURE: "false" }
     });
@@ -6703,7 +9575,7 @@ function runGateViaStdin(opts) {
       if (settled)
         return;
       settled = true;
-      resolve2(r);
+      resolve6(r);
     };
     const timer = setTimeout(() => {
       try {
@@ -6982,7 +9854,7 @@ async function runMineLocal(args) {
       return;
     lockReleased = true;
     try {
-      unlinkSync10(LOCAL_MINE_LOCK_PATH);
+      unlinkSync12(LOCAL_MINE_LOCK_PATH);
     } catch {
     }
   };
@@ -7039,8 +9911,8 @@ async function runMineLocalImpl(args) {
     console.log(`Dry-run: would invoke ${gateAgent} gate on ${picked.length} session(s) in parallel (concurrency=${GATE_CONCURRENCY}).`);
     return;
   }
-  const tmpDir = join31(homedir18(), ".claude", "hivemind", `mine-local-${Date.now()}`);
-  mkdirSync12(tmpDir, { recursive: true });
+  const tmpDir = join45(homedir23(), ".claude", "hivemind", `mine-local-${Date.now()}`);
+  mkdirSync22(tmpDir, { recursive: true });
   console.log(`Running ${picked.length} gate call(s) in parallel (concurrency=${GATE_CONCURRENCY}, timeout=${GATE_TIMEOUT_MS / 1e3}s each)...`);
   const results = await parallelMap(picked, GATE_CONCURRENCY, async (s) => {
     const shortId = s.sessionId.slice(0, 8);
@@ -7051,23 +9923,23 @@ async function runMineLocalImpl(args) {
       return { session: s, skills: [], reason: "no pairs", error: null };
     }
     const tail = pairs2.slice(-PER_SESSION_PAIR_CAP);
-    const sessionTmp = join31(tmpDir, `s-${shortId}`);
-    mkdirSync12(sessionTmp, { recursive: true });
-    const verdictPath = join31(sessionTmp, "verdict.json");
+    const sessionTmp = join45(tmpDir, `s-${shortId}`);
+    mkdirSync22(sessionTmp, { recursive: true });
+    const verdictPath = join45(sessionTmp, "verdict.json");
     const prompt = buildSessionPrompt(tail, s, verdictPath);
-    writeFileSync16(join31(sessionTmp, "prompt.txt"), prompt);
+    writeFileSync24(join45(sessionTmp, "prompt.txt"), prompt);
     const gate = await runGateViaStdin({ agent: gateAgent, bin: gateBin, prompt, timeoutMs: GATE_TIMEOUT_MS });
     try {
-      writeFileSync16(join31(sessionTmp, "gate-stdout.txt"), gate.stdout);
+      writeFileSync24(join45(sessionTmp, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync16(join31(sessionTmp, "gate-stderr.txt"), gate.stderr);
+        writeFileSync24(join45(sessionTmp, "gate-stderr.txt"), gate.stderr);
     } catch {
     }
     if (gate.errored) {
       console.log(`  [${shortId}] gate failed: ${gate.errorMessage}`);
       return { session: s, skills: [], reason: null, error: gate.errorMessage ?? "gate failed" };
     }
-    const verdictText = existsSync25(verdictPath) ? readFileSync21(verdictPath, "utf-8") : gate.stdout;
+    const verdictText = existsSync35(verdictPath) ? readFileSync31(verdictPath, "utf-8") : gate.stdout;
     const mv = parseMultiVerdict(verdictText);
     if (!mv) {
       console.log(`  [${shortId}] unparseable verdict (kept at ${sessionTmp})`);
@@ -7119,8 +9991,8 @@ async function runMineLocalImpl(args) {
         sourceSessions: [session.sessionId],
         agent: gateAgent
       });
-      const canonicalDir = dirname7(result.path);
-      const symlinks = fanOutRoots.length > 0 ? fanOutSymlinks(canonicalDir, basename(canonicalDir), fanOutRoots) : [];
+      const canonicalDir = dirname16(result.path);
+      const symlinks = fanOutRoots.length > 0 ? fanOutSymlinks(canonicalDir, basename2(canonicalDir), fanOutRoots) : [];
       const symlinkSuffix = symlinks.length > 0 ? `, fan-out \u2192 ${symlinks.length} root(s)` : "";
       console.log(`  wrote ${skill.name} \u2190 session ${session.sessionId.slice(0, 8)} (${session.agent}${symlinkSuffix})`);
       written.push({ skill, session, result, symlinks });
@@ -7296,11 +10168,11 @@ function showStatus() {
   console.log(`team:    ${cfg.team.length === 0 ? "(empty)" : cfg.team.join(", ")}`);
   console.log(`install: ${cfg.install}  (${cfg.install === "global" ? "~/.claude/skills/" : "<project>/.claude/skills/"})`);
   const dir = stateDir();
-  if (!existsSync26(dir)) {
+  if (!existsSync36(dir)) {
     console.log(`state: (no projects tracked yet)`);
     return;
   }
-  const files = readdirSync5(dir).filter((f) => f.endsWith(".json") && f !== "config.json" && f !== "pulled.json" && f !== "autopull-last-run.json");
+  const files = readdirSync8(dir).filter((f) => f.endsWith(".json") && f !== "config.json" && f !== "pulled.json" && f !== "autopull-last-run.json");
   if (files.length === 0) {
     console.log(`state: (no projects tracked yet)`);
     return;
@@ -7308,7 +10180,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync22(join32(dir, f), "utf-8"));
+      const s = JSON.parse(readFileSync32(join46(dir, f), "utf-8"));
       const last = typeof s.updatedAt === "number" ? new Date(s.updatedAt).toISOString() : s.lastDate ?? "never";
       const skills = Array.isArray(s.skillsGenerated) && s.skillsGenerated.length > 0 ? s.skillsGenerated.join(", ") : "none";
       console.log(`  - ${s.project} (counter=${s.counter}, last=${last}, skills=${skills})`);
@@ -7335,7 +10207,7 @@ function setInstall(loc) {
   }
   const cfg = loadScopeConfig();
   saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join32(homedir19(), ".claude", "skills") : "<cwd>/.claude/skills";
+  const path = loc === "global" ? join46(homedir24(), ".claude", "skills") : "<cwd>/.claude/skills";
   console.log(`Install location set to '${loc}'. New skills will be written to ${path}/<name>/SKILL.md.`);
 }
 function promoteSkill(name, cwd) {
@@ -7343,18 +10215,18 @@ function promoteSkill(name, cwd) {
     console.error("Usage: hivemind skillify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join32(cwd, ".claude", "skills", name);
-  const globalPath = join32(homedir19(), ".claude", "skills", name);
-  if (!existsSync26(join32(projectPath, "SKILL.md"))) {
+  const projectPath = join46(cwd, ".claude", "skills", name);
+  const globalPath = join46(homedir24(), ".claude", "skills", name);
+  if (!existsSync36(join46(projectPath, "SKILL.md"))) {
     console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
     process.exit(1);
   }
-  if (existsSync26(join32(globalPath, "SKILL.md"))) {
+  if (existsSync36(join46(globalPath, "SKILL.md"))) {
     console.error(`Skill '${name}' already exists at ${globalPath}/SKILL.md \u2014 refusing to overwrite. Remove it first or rename the project skill.`);
     process.exit(1);
   }
-  mkdirSync13(dirname8(globalPath), { recursive: true });
-  renameSync7(projectPath, globalPath);
+  mkdirSync23(dirname17(globalPath), { recursive: true });
+  renameSync12(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
 function teamAdd(name) {
@@ -7460,7 +10332,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join32(homedir19(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join46(homedir24(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterDesc = users.length === 0 ? "all users" : users.join(", ");
   console.log(`Destination: ${dest}`);
   console.log(`Filter:      ${filterDesc}${skillName ? ` \xB7 skill='${skillName}'` : ""}${dryRun ? " \xB7 dry-run" : ""}${force ? " \xB7 force" : ""}`);
@@ -7510,7 +10382,7 @@ async function unpullSkills(args) {
     all,
     legacyCleanup
   });
-  const dest = toRaw === "global" ? join32(homedir19(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join46(homedir24(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterParts = [];
   if (users.length > 0)
     filterParts.push(`users=${users.join(",")}`);
@@ -7605,15 +10477,15 @@ if (process.argv[1] && process.argv[1].endsWith("skillify.js")) {
 }
 
 // dist/src/cli/update.js
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync27, mkdirSync as mkdirSync14, openSync as openSync2, readFileSync as readFileSync24, realpathSync, unlinkSync as unlinkSync11, writeSync } from "node:fs";
-import { homedir as homedir20 } from "node:os";
-import { dirname as dirname10, join as join34, sep } from "node:path";
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { closeSync as closeSync3, existsSync as existsSync37, mkdirSync as mkdirSync24, openSync as openSync3, readFileSync as readFileSync34, realpathSync, unlinkSync as unlinkSync13, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir25 } from "node:os";
+import { dirname as dirname19, join as join48, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/src/utils/version-check.js
-import { readFileSync as readFileSync23 } from "node:fs";
-import { dirname as dirname9, join as join33 } from "node:path";
+import { readFileSync as readFileSync33 } from "node:fs";
+import { dirname as dirname18, join as join47 } from "node:path";
 function isNewer(latest, current) {
   const parse = (v) => v.split(".").map(Number);
   const [la, lb, lc] = parse(latest);
@@ -7625,7 +10497,7 @@ function isNewer(latest, current) {
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@deeplake/hivemind/latest";
 var PKG_NAME = "@deeplake/hivemind";
 function defaultLockPath() {
-  return join34(homedir20(), ".deeplake", "hivemind-update.lock");
+  return join48(homedir25(), ".deeplake", "hivemind-update.lock");
 }
 function detectInstallKind(argv1) {
   const realArgv1 = (() => {
@@ -7635,36 +10507,36 @@ function detectInstallKind(argv1) {
       return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
     }
   })();
-  let dir = dirname10(realArgv1);
+  let dir = dirname19(realArgv1);
   let installDir = null;
   for (let i = 0; i < 10; i++) {
-    const pkgPath = `${dir}${sep}package.json`;
+    const pkgPath = `${dir}${sep2}package.json`;
     try {
-      const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync34(pkgPath, "utf-8"));
       if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
         installDir = dir;
         break;
       }
     } catch {
     }
-    const parent = dirname10(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  installDir ??= dirname10(realArgv1);
-  if (realArgv1.includes(`${sep}_npx${sep}`) || realArgv1.includes(`${sep}.npx${sep}`)) {
+  installDir ??= dirname19(realArgv1);
+  if (realArgv1.includes(`${sep2}_npx${sep2}`) || realArgv1.includes(`${sep2}.npx${sep2}`)) {
     return { kind: "npx", installDir };
   }
-  if (realArgv1.includes(`${sep}node_modules${sep}@deeplake${sep}hivemind`) || realArgv1.includes(`${sep}node_modules${sep}hivemind`)) {
+  if (realArgv1.includes(`${sep2}node_modules${sep2}@deeplake${sep2}hivemind`) || realArgv1.includes(`${sep2}node_modules${sep2}hivemind`)) {
     return { kind: "npm-global", installDir };
   }
   let gitDir = installDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync27(`${gitDir}${sep}.git`)) {
+    if (existsSync37(`${gitDir}${sep2}.git`)) {
       return { kind: "local-dev", installDir };
     }
-    const parent = dirname10(gitDir);
+    const parent = dirname19(gitDir);
     if (parent === gitDir)
       break;
     gitDir = parent;
@@ -7683,13 +10555,13 @@ async function getLatestNpmVersion(timeoutMs = 5e3) {
   }
 }
 var defaultSpawn = (cmd, args) => {
-  execFileSync4(cmd, args, { stdio: "inherit" });
+  execFileSync6(cmd, args, { stdio: "inherit" });
 };
 function tryAcquireLock(path) {
-  mkdirSync14(dirname10(path), { recursive: true, mode: 448 });
+  mkdirSync24(dirname19(path), { recursive: true, mode: 448 });
   const claim = () => {
-    const fd = openSync2(path, "wx", 384);
-    writeSync(fd, String(process.pid));
+    const fd = openSync3(path, "wx", 384);
+    writeSync2(fd, String(process.pid));
     return fd;
   };
   try {
@@ -7700,7 +10572,7 @@ function tryAcquireLock(path) {
   }
   let holderPid = 0;
   try {
-    holderPid = Number(readFileSync24(path, "utf-8").trim()) || 0;
+    holderPid = Number(readFileSync34(path, "utf-8").trim()) || 0;
   } catch {
     try {
       return claim();
@@ -7717,7 +10589,7 @@ function tryAcquireLock(path) {
     }
   }
   try {
-    unlinkSync11(path);
+    unlinkSync13(path);
   } catch {
   }
   try {
@@ -7729,11 +10601,11 @@ function tryAcquireLock(path) {
 }
 function releaseLock(fd, path) {
   try {
-    closeSync2(fd);
+    closeSync3(fd);
   } catch {
   }
   try {
-    unlinkSync11(path);
+    unlinkSync13(path);
   } catch {
   }
 }
@@ -7751,7 +10623,7 @@ async function runUpdate(opts = {}) {
   }
   log(`Update available: ${current} \u2192 ${latest}`);
   const detected = opts.installKindOverride ?? detectInstallKind();
-  const spawn2 = opts.spawn ?? defaultSpawn;
+  const spawn3 = opts.spawn ?? defaultSpawn;
   switch (detected.kind) {
     case "npm-global": {
       if (opts.dryRun) {
@@ -7766,7 +10638,7 @@ async function runUpdate(opts = {}) {
       try {
         log(`Upgrading via npm\u2026`);
         try {
-          spawn2("npm", ["install", "-g", `${PKG_NAME}@latest`]);
+          spawn3("npm", ["install", "-g", `${PKG_NAME}@latest`]);
         } catch (e) {
           warn(`npm install failed: ${e.message}`);
           warn(`Try running it manually: npm install -g ${PKG_NAME}@latest`);
@@ -7775,7 +10647,7 @@ async function runUpdate(opts = {}) {
         log(``);
         log(`Refreshing agent bundles\u2026`);
         try {
-          spawn2("hivemind", ["install", "--skip-auth"]);
+          spawn3("hivemind", ["install", "--skip-auth"]);
         } catch (e) {
           warn(`Agent refresh failed: ${e.message}`);
           warn(`Run manually: hivemind install`);
@@ -7839,7 +10711,7 @@ var AUTH_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "autoupdate",
   "sessions"
 ]);
-var USAGE = `
+var USAGE3 = `
 hivemind \u2014 one brain for every agent on your team
 
 Usage:
@@ -7869,6 +10741,18 @@ Usage:
       Check npm for a newer @deeplake/hivemind, upgrade the CLI, and refresh
       every detected agent bundle. Single command for all agents.
 
+  hivemind dashboard [--cwd <path>] [--out <path>] [--no-open]
+                     [--serve] [--port <n>]
+      Build a self-contained HTML dashboard for this repo. Combines
+      KPI cards (tokens saved, skills created, memory recalls,
+      sessions) with the codebase-graph visualization. Writes to
+      ~/.hivemind/dashboards/<repo-key>/index.html by default.
+      --no-open skips the browser launch (headless / CI scenarios).
+      --serve starts a loopback HTTP server at http://127.0.0.1:<port>
+      (default 8123) so the dashboard is reachable via a URL \u2014 useful
+      over SSH; VS Code / Cursor Remote-SSH auto-forwards the port
+      and opens it in the integrated Simple Browser tab on click.
+
 Semantic search (embeddings):
   hivemind embeddings install                Download @huggingface/transformers
                                              once (~600 MB) into a shared dir,
@@ -7897,6 +10781,22 @@ Semantic search (embeddings):
   Add --with-embeddings to "hivemind install" (or "hivemind <agent> install")
   to run "embeddings install" automatically after installing the agent(s).
 
+Codebase graph (per-repo AST snapshot + cloud sync):
+  hivemind graph build [--cwd <path>]        Walk TypeScript sources, extract
+                                             AST nodes + edges, write a
+                                             snapshot, and push to cloud.
+  hivemind graph diff <sha1> <sha2>          Diff two snapshots by commit.
+  hivemind graph history [-n N] [--json]     Show last N build entries.
+  hivemind graph init [--force]              Install a managed
+                                             .git/hooks/post-commit hook
+                                             that rebuilds on each commit.
+  hivemind graph pull                        Download the freshest cloud
+                                             snapshot for HEAD into local.
+  hivemind graph uninstall                   Remove the managed post-commit
+                                             hook.
+  Agents query the local snapshot via the Deeplake mount at
+  ~/.deeplake/memory/graph/{index.md,find/<pattern>,show/<handle-or-pattern>}.
+
 Skill management (mine + share reusable Claude skills across the org):
 ${renderCliHelpBlock()}
 
@@ -8087,7 +10987,7 @@ async function main() {
   const args = process.argv.slice(2);
   const cmd = args[0];
   if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
-    log(USAGE);
+    log(USAGE3);
     return;
   }
   if (cmd === "--version" || cmd === "-v" || cmd === "version") {
@@ -8121,6 +11021,14 @@ async function main() {
     runSkillifyCommand(args.slice(1));
     return;
   }
+  if (cmd === "graph") {
+    await runGraphCommand(args.slice(1));
+    return;
+  }
+  if (cmd === "dashboard") {
+    const code = await runDashboardCommand(args.slice(1));
+    process.exit(code);
+  }
   if (cmd === "embeddings") {
     const sub = args[1];
     if (sub === "install") {
@@ -8168,7 +11076,7 @@ async function main() {
     return;
   }
   warn(`Unknown command: ${cmd}`);
-  log(USAGE);
+  log(USAGE3);
   process.exit(1);
 }
 main().catch((err) => {