@deeplake/hivemind 0.7.45 → 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((resolve3) => {
+  return new Promise((resolve6) => {
     rl.question(`${message} ${hint} `, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
       if (a === "")
-        resolve3(defaultYes);
+        resolve6(defaultYes);
       else
-        resolve3(a === "y" || a === "yes");
+        resolve6(a === "y" || a === "yes");
     });
   });
 }
 function promptLine(message) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve3) => {
+  return new Promise((resolve6) => {
     rl.question(message, (answer) => {
       rl.close();
-      resolve3(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((resolve3) => setTimeout(resolve3, 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((resolve3) => this.waiting.push(resolve3));
+    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();
@@ -5347,96 +5390,1950 @@ async function runAuthCommand(args) {
       console.log(`Invited ${email} with ${mode} access`);
       break;
     }
-    case "members": {
-      if (!creds) {
-        console.log("Not logged in.");
-        process.exit(1);
-      }
-      const members = await listMembers(creds.token, creds.orgId, apiUrl);
-      members.forEach((m) => console.log(`${m.role.padEnd(8)} ${m.email ?? m.name}`));
+    case "members": {
+      if (!creds) {
+        console.log("Not logged in.");
+        process.exit(1);
+      }
+      const members = await listMembers(creds.token, creds.orgId, apiUrl);
+      members.forEach((m) => console.log(`${m.role.padEnd(8)} ${m.email ?? m.name}`));
+      break;
+    }
+    case "remove": {
+      if (!creds) {
+        console.log("Not logged in.");
+        process.exit(1);
+      }
+      const userId = args[1];
+      if (!userId) {
+        console.log("Usage: remove <user-id>");
+        process.exit(1);
+      }
+      await removeMember(userId, creds.token, creds.orgId, apiUrl);
+      console.log(`Removed user ${userId}`);
+      break;
+    }
+    case "sessions": {
+      const sub = args[1];
+      if (sub === "prune") {
+        await sessionPrune(args.slice(2));
+      } else {
+        console.log("Usage: sessions prune [--all | --before <date> | --session-id <id>] [--yes]");
+      }
+      break;
+    }
+    case "autoupdate": {
+      if (!creds) {
+        console.log("Not logged in.");
+        process.exit(1);
+      }
+      const val = args[1]?.toLowerCase();
+      if (val === "on" || val === "true") {
+        saveCredentials({ ...creds, autoupdate: true });
+        console.log("Autoupdate enabled. Plugin will update automatically on session start.");
+      } else if (val === "off" || val === "false") {
+        saveCredentials({ ...creds, autoupdate: false });
+        console.log("Autoupdate disabled. You'll see a notice when updates are available.");
+      } else {
+        const current = creds.autoupdate !== false ? "on" : "off";
+        console.log(`Autoupdate is currently: ${current}`);
+        console.log("Usage: autoupdate [on|off]");
+      }
+      break;
+    }
+    case "logout": {
+      if (deleteCredentials()) {
+        console.log("Logged out. Credentials removed.");
+      } else {
+        console.log("Not logged in.");
+      }
+      break;
+    }
+    default:
+      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);
+  });
+}
+
+// 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 "remove": {
-      if (!creds) {
-        console.log("Not logged in.");
-        process.exit(1);
-      }
-      const userId = args[1];
-      if (!userId) {
-        console.log("Usage: remove <user-id>");
-        process.exit(1);
-      }
-      await removeMember(userId, creds.token, creds.orgId, apiUrl);
-      console.log(`Removed user ${userId}`);
+    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);
     }
-    case "sessions": {
-      const sub = args[1];
-      if (sub === "prune") {
-        await sessionPrune(args.slice(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("Usage: sessions prune [--all | --before <date> | --session-id <id>] [--yes]");
+        console.log(`Removed managed block from post-commit hook (other content preserved): ${status.path}`);
       }
+      console.log("Local snapshots + history.jsonl are untouched.");
       break;
-    }
-    case "autoupdate": {
-      if (!creds) {
-        console.log("Not logged in.");
-        process.exit(1);
+    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);
       }
-      const val = args[1]?.toLowerCase();
-      if (val === "on" || val === "true") {
-        saveCredentials({ ...creds, autoupdate: true });
-        console.log("Autoupdate enabled. Plugin will update automatically on session start.");
-      } else if (val === "off" || val === "false") {
-        saveCredentials({ ...creds, autoupdate: false });
-        console.log("Autoupdate disabled. You'll see a notice when updates are available.");
+      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 {
-        const current = creds.autoupdate !== false ? "on" : "off";
-        console.log(`Autoupdate is currently: ${current}`);
-        console.log("Usage: autoupdate [on|off]");
+        console.error(`hivemind graph build: --trigger must be one of manual|session-end|post-commit|unknown (got '${v}')`);
+        process.exit(2);
       }
-      break;
-    }
-    case "logout": {
-      if (deleteCredentials()) {
-        console.log("Logged out. Credentials removed.");
+      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 {
-        console.log("Not logged in.");
+        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);
     }
-    default:
-      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);
-  });
+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 mkdirSync10, writeFileSync as writeFileSync13 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { dirname as dirname6, join as join27, resolve as resolve2 } from "node:path";
+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 existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { join as join25 } from "node:path";
+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 existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname3, join as join20 } from "node:path";
+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 join20(homedir10(), ".deeplake", "hivemind-stats-cache.json");
+  return join28(homedir11(), ".deeplake", "hivemind-stats-cache.json");
 }
 function cacheScopeKey(creds) {
   return JSON.stringify({
@@ -5453,11 +7350,11 @@ function scopeFromServer(s) {
     memorySearchBytes: n(s?.memory_search_bytes)
   };
 }
-function readCache(scopeKey) {
-  if (!existsSync15(cacheFilePath()))
+function readCache2(scopeKey) {
+  if (!existsSync21(cacheFilePath()))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync15(cacheFilePath(), "utf-8"));
+    const parsed = JSON.parse(readFileSync21(cacheFilePath(), "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return {};
     if (parsed.scopeKey !== scopeKey)
@@ -5476,11 +7373,11 @@ function readCache(scopeKey) {
     return {};
   }
 }
-function writeCache(scopeKey, data) {
+function writeCache2(scopeKey, data) {
   try {
-    mkdirSync7(dirname3(cacheFilePath()), { recursive: true });
+    mkdirSync13(dirname9(cacheFilePath()), { recursive: true });
     const body = { fetchedAt: Date.now(), scopeKey, data };
-    writeFileSync11(cacheFilePath(), JSON.stringify(body), "utf-8");
+    writeFileSync16(cacheFilePath(), JSON.stringify(body), "utf-8");
   } catch (e) {
     log5(`cache write failed: ${e?.message ?? String(e)}`);
   }
@@ -5490,7 +7387,7 @@ async function fetchOrgStats(creds) {
     return null;
   const apiUrl = creds.apiUrl ?? DEFAULT_API_URL3;
   const scopeKey = cacheScopeKey(creds);
-  const { fresh, stale } = readCache(scopeKey);
+  const { fresh, stale } = readCache2(scopeKey);
   if (fresh) {
     log5("cache hit \u2014 returning fresh org stats");
     return fresh;
@@ -5519,7 +7416,7 @@ async function fetchOrgStats(creds) {
       org: scopeFromServer(body.org),
       user: scopeFromServer(body.user)
     };
-    writeCache(scopeKey, data);
+    writeCache2(scopeKey, data);
     log5(`fetched org stats from ${apiUrl}`);
     return data;
   } catch (e) {
@@ -5531,18 +7428,18 @@ async function fetchOrgStats(creds) {
 }
 
 // dist/src/notifications/usage-tracker.js
-import { appendFileSync as appendFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync2 } from "node:fs";
-import { dirname as dirname4, join as join21 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+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 join21(homedir11(), ".deeplake", "usage-stats.jsonl");
+  return join29(homedir12(), ".deeplake", "usage-stats.jsonl");
 }
 function readUsageRecords() {
   try {
-    if (!existsSync16(statsFilePath()))
+    if (!existsSync22(statsFilePath()))
       return [];
-    const raw = readFileSync16(statsFilePath(), "utf-8");
+    const raw = readFileSync22(statsFilePath(), "utf-8");
     const out = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -5579,13 +7476,13 @@ function sumMetric(records, key) {
 function countUserGeneratedSkills(userName) {
   if (!userName)
     return 0;
-  const dir = join21(homedir11(), ".claude", "skills");
-  if (!existsSync16(dir))
+  const dir = join29(homedir12(), ".claude", "skills");
+  if (!existsSync22(dir))
     return 0;
   const suffix = `--${userName}`;
   try {
     let count = 0;
-    for (const name of readdirSync2(dir)) {
+    for (const name of readdirSync3(dir)) {
       const idx = name.lastIndexOf(suffix);
       if (idx > 0 && idx + suffix.length === name.length)
         count += 1;
@@ -5598,21 +7495,19 @@ function countUserGeneratedSkills(userName) {
 }
 
 // dist/src/skillify/state.js
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync12, writeSync, mkdirSync as mkdirSync9, renameSync as renameSync5, rmdirSync, existsSync as existsSync18, lstatSync as lstatSync3, unlinkSync as unlinkSync8, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
-import { execSync as execSync2 } from "node:child_process";
-import { createHash } from "node:crypto";
-import { join as join24, basename } from "node:path";
+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 existsSync17, renameSync as renameSync4 } from "node:fs";
-import { dirname as dirname5, join as join23 } 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 homedir12 } from "node:os";
-import { join as join22 } 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 : join22(homedir12(), ".deeplake", "state", "skillify");
+  return override && override.length > 0 ? override : join30(homedir13(), ".deeplake", "state", "skillify");
 }
 
 // dist/src/skillify/legacy-migration.js
@@ -5625,13 +7520,13 @@ function migrateLegacyStateDir() {
     return;
   attempted = true;
   const current = getStateDir();
-  const legacy = join23(dirname5(current), "skilify");
-  if (!existsSync17(legacy))
+  const legacy = join31(dirname11(current), "skilify");
+  if (!existsSync23(legacy))
     return;
-  if (existsSync17(current))
+  if (existsSync23(current))
     return;
   try {
-    renameSync4(legacy, current);
+    renameSync8(legacy, current);
     dlog(`migrated ${legacy} -> ${current}`);
   } catch (err) {
     const code = err.code;
@@ -5649,54 +7544,13 @@ var TRIGGER_THRESHOLD = (() => {
   const n = Number(process.env.HIVEMIND_SKILLIFY_EVERY_N_TURNS ?? "");
   return Number.isInteger(n) && n > 0 ? n : 20;
 })();
-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 project = basename(cwd) || "unknown";
-  let signature = null;
-  try {
-    const raw = execSync2("git config --get remote.origin.url", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    signature = raw ? normalizeGitRemoteUrl(raw) : null;
-  } catch {
-  }
-  const input = signature ?? cwd;
-  const key = createHash("sha1").update(input).digest("hex").slice(0, 16);
-  return { key, project };
-}
 
 // dist/src/dashboard/data.js
 var log7 = (msg) => log2("dashboard-data", msg);
 var BYTES_PER_TOKEN = 4;
 var SAVINGS_MULTIPLIER = 1.7;
-function graphsRoot() {
-  return process.env.HIVEMIND_GRAPHS_HOME ?? join25(homedir13(), ".hivemind", "graphs");
+function graphsRoot2() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join33(homedir14(), ".hivemind", "graphs");
 }
 function bytesToSavedTokens(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0)
@@ -5704,18 +7558,18 @@ function bytesToSavedTokens(bytes) {
   const delivered = bytes / BYTES_PER_TOKEN;
   return (SAVINGS_MULTIPLIER - 1) * delivered;
 }
-function resolveSnapshot(repoDir) {
-  const snapshotsDir = join25(repoDir, "snapshots");
-  if (!existsSync19(snapshotsDir))
+function resolveSnapshot(repoDir2) {
+  const snapshotsDir = join33(repoDir2, "snapshots");
+  if (!existsSync25(snapshotsDir))
     return null;
   let snapshotPath = null;
-  const pointer = join25(repoDir, "latest-commit.txt");
-  if (existsSync19(pointer)) {
+  const pointer = join33(repoDir2, "latest-commit.txt");
+  if (existsSync25(pointer)) {
     try {
-      const sha = readFileSync18(pointer, "utf-8").trim();
+      const sha = readFileSync24(pointer, "utf-8").trim();
       if (sha) {
-        const candidate = join25(snapshotsDir, `${sha}.json`);
-        if (existsSync19(candidate))
+        const candidate = join33(snapshotsDir, `${sha}.json`);
+        if (existsSync25(candidate))
           snapshotPath = candidate;
         else
           log7(`latest-commit.txt points at missing ${sha}.json \u2014 scanning snapshots/`);
@@ -5726,8 +7580,8 @@ function resolveSnapshot(repoDir) {
   }
   if (!snapshotPath) {
     try {
-      const candidates = readdirSync3(snapshotsDir).filter((name) => name.endsWith(".json")).map((name) => {
-        const full = join25(snapshotsDir, name);
+      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)
@@ -5740,7 +7594,7 @@ function resolveSnapshot(repoDir) {
     return null;
   let raw;
   try {
-    raw = readFileSync18(snapshotPath, "utf-8");
+    raw = readFileSync24(snapshotPath, "utf-8");
   } catch (e) {
     log7(`snapshot read failed: ${e?.message ?? String(e)}`);
     return null;
@@ -5810,8 +7664,8 @@ async function loadKpis(creds) {
 async function loadDashboardData(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const { key: repoKey, project: repoProject } = deriveProjectKey(cwd);
-  const repoDir = join25(opts.graphsHome ?? graphsRoot(), repoKey);
-  const graph = resolveSnapshot(repoDir);
+  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 {
@@ -5827,7 +7681,7 @@ async function loadDashboardData(opts = {}) {
 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 join26 } from "node:path";
+import { delimiter, join as join34 } from "node:path";
 function resolveOpenPlatform() {
   const p = nodePlatform();
   if (p === "linux" || p === "darwin" || p === "win32")
@@ -5854,7 +7708,7 @@ function findBinaryOnPath(name) {
     if (!dir)
       continue;
     for (const ext of exts) {
-      const candidate = join26(dir, name + ext);
+      const candidate = join34(dir, name + ext);
       try {
         const st = statSync4(candidate);
         if (!st.isFile())
@@ -6193,7 +8047,7 @@ function handleRequest(html) {
   };
 }
 function tryListen(server, host, port) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve6, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
@@ -6205,7 +8059,7 @@ function tryListen(server, host, port) {
         reject(new Error("server bound to a non-IP address"));
         return;
       }
-      resolve3(addr.port);
+      resolve6(addr.port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -6231,22 +8085,22 @@ async function serveDashboardHtml(opts) {
 }
 function makeHandle(server, host, port) {
   let resolveStopped;
-  const stopped = new Promise((resolve3) => {
-    resolveStopped = resolve3;
+  const stopped = new Promise((resolve6) => {
+    resolveStopped = resolve6;
   });
   server.on("close", () => resolveStopped());
   return {
     host,
     port,
     stopped,
-    close: () => new Promise((resolve3, reject) => {
-      server.close((err) => err ? reject(err) : resolve3());
+    close: () => new Promise((resolve6, reject) => {
+      server.close((err) => err ? reject(err) : resolve6());
     })
   };
 }
 
 // dist/src/commands/dashboard.js
-var USAGE = `hivemind dashboard \u2014 codebase graph + KPI dashboard (HTML)
+var USAGE2 = `hivemind dashboard \u2014 codebase graph + KPI dashboard (HTML)
 
 Usage:
   hivemind dashboard [--cwd <path>] [--out <path>] [--no-open]
@@ -6364,7 +8218,7 @@ function parseDashboardArgs(args) {
   };
 }
 function defaultDashboardOutPath(repoKey) {
-  return join27(homedir14(), ".hivemind", "dashboards", repoKey, "index.html");
+  return join35(homedir15(), ".hivemind", "dashboards", repoKey, "index.html");
 }
 async function runDashboardCommand(rawArgs, runOpts = {}) {
   const out = runOpts.out ?? ((s) => {
@@ -6376,13 +8230,13 @@ async function runDashboardCommand(rawArgs, runOpts = {}) {
   const opener = runOpts.opener ?? openInBrowser;
   const parsed = parseDashboardArgs(rawArgs);
   if (parsed.help) {
-    out(USAGE);
+    out(USAGE2);
     return 0;
   }
   if (parsed.error || !parsed.args) {
     err(`hivemind dashboard: ${parsed.error ?? "invalid arguments"}
 `);
-    err(USAGE);
+    err(USAGE2);
     return 2;
   }
   const { cwd, outPath, open } = parsed.args;
@@ -6396,10 +8250,10 @@ async function runDashboardCommand(rawArgs, runOpts = {}) {
   }
   const html = renderDashboardHtml(data);
   const finalOut = outPath || defaultDashboardOutPath(data.repoKey);
-  const absOut = resolve2(finalOut);
+  const absOut = resolve5(finalOut);
   try {
-    mkdirSync10(dirname6(absOut), { recursive: true });
-    writeFileSync13(absOut, html, "utf-8");
+    mkdirSync16(dirname12(absOut), { recursive: true });
+    writeFileSync18(absOut, html, "utf-8");
   } catch (e) {
     err(`hivemind dashboard: failed to write ${absOut}: ${e?.message ?? String(e)}
 `);
@@ -6478,24 +8332,24 @@ function defaultOnSignal(signal, handler) {
 }
 
 // dist/src/commands/skillify.js
-import { readdirSync as readdirSync7, existsSync as existsSync30, readFileSync as readFileSync26, mkdirSync as mkdirSync17, renameSync as renameSync8 } from "node:fs";
-import { homedir as homedir23 } from "node:os";
-import { dirname as dirname11, join as join38 } from "node:path";
+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 existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join28 } from "node:path";
+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 join28(getStateDir(), "config.json");
+  return join36(getStateDir(), "config.json");
 }
 var DEFAULT = { scope: "me", team: [], install: "project" };
 function loadScopeConfig() {
   migrateLegacyStateDir();
   const CONFIG_PATH2 = configPath();
-  if (!existsSync20(CONFIG_PATH2))
+  if (!existsSync26(CONFIG_PATH2))
     return DEFAULT;
   try {
-    const raw = JSON.parse(readFileSync19(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";
@@ -6506,19 +8360,19 @@ function loadScopeConfig() {
 }
 function saveScopeConfig(cfg) {
   migrateLegacyStateDir();
-  mkdirSync11(getStateDir(), { recursive: true });
-  writeFileSync14(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 existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync17, mkdirSync as mkdirSync14, renameSync as renameSync7, lstatSync as lstatSync5, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync10 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname8, join as join32 } 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 existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { join as join29 } 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`);
@@ -6534,10 +8388,10 @@ function assertValidSkillName(name) {
   }
 }
 function skillDir(skillsRoot, name) {
-  return join29(skillsRoot, name);
+  return join37(skillsRoot, name);
 }
 function skillPath(skillsRoot, name) {
-  return join29(skillDir(skillsRoot, name), "SKILL.md");
+  return join37(skillDir(skillsRoot, name), "SKILL.md");
 }
 function renderFrontmatter(fm) {
   const lines = ["---"];
@@ -6615,10 +8469,10 @@ function writeNewSkill(args) {
   assertValidSkillName(args.name);
   const dir = skillDir(args.skillsRoot, args.name);
   const path = skillPath(args.skillsRoot, args.name);
-  if (existsSync21(path)) {
+  if (existsSync27(path)) {
     throw new Error(`skill already exists at ${path}; use mergeSkill`);
   }
-  mkdirSync12(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] : [];
@@ -6638,7 +8492,7 @@ function writeNewSkill(args) {
 
 ${args.body.trim()}
 `;
-  writeFileSync15(path, text);
+  writeFileSync20(path, text);
   return {
     path,
     action: "created",
@@ -6650,40 +8504,40 @@ ${args.body.trim()}
   };
 }
 function listSkills(skillsRoot) {
-  if (!existsSync21(skillsRoot))
+  if (!existsSync27(skillsRoot))
     return [];
   const out = [];
-  for (const name of readdirSync4(skillsRoot)) {
-    const skillFile = join29(skillsRoot, name, "SKILL.md");
-    if (existsSync21(skillFile) && statSync5(skillFile).isFile()) {
-      out.push({ name, body: readFileSync20(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 join29(homedir15(), ".claude", "skills");
+    return join37(homedir16(), ".claude", "skills");
   }
-  return join29(cwd, ".claude", "skills");
+  return join37(cwd, ".claude", "skills");
 }
 
 // dist/src/skillify/manifest.js
-import { existsSync as existsSync22, lstatSync as lstatSync4, mkdirSync as mkdirSync13, readFileSync as readFileSync21, renameSync as renameSync6, unlinkSync as unlinkSync9, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname7, join as join30 } 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 join30(getStateDir(), "pulled.json");
+  return join38(getStateDir(), "pulled.json");
 }
 function loadManifest(path = manifestPath()) {
   migrateLegacyStateDir();
-  if (!existsSync22(path))
+  if (!existsSync28(path))
     return emptyManifest();
   let raw;
   try {
-    raw = readFileSync21(path, "utf-8");
+    raw = readFileSync27(path, "utf-8");
   } catch {
     return emptyManifest();
   }
@@ -6730,10 +8584,10 @@ function loadManifest(path = manifestPath()) {
 }
 function saveManifest(m, path = manifestPath()) {
   migrateLegacyStateDir();
-  mkdirSync13(dirname7(path), { recursive: true });
+  mkdirSync19(dirname13(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  writeFileSync16(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
-  renameSync6(tmp, path);
+  writeFileSync21(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  renameSync10(tmp, path);
 }
 function recordPull(entry, path = manifestPath()) {
   const m = loadManifest(path);
@@ -6765,7 +8619,7 @@ function unlinkSymlinks(paths) {
     if (!st.isSymbolicLink())
       continue;
     try {
-      unlinkSync9(path);
+      unlinkSync10(path);
     } catch {
     }
   }
@@ -6775,7 +8629,7 @@ function pruneOrphanedEntries(path = manifestPath()) {
   const live = [];
   let pruned = 0;
   for (const e of m.entries) {
-    if (existsSync22(join30(e.installRoot, e.dirName))) {
+    if (existsSync28(join38(e.installRoot, e.dirName))) {
       live.push(e);
       continue;
     }
@@ -6788,26 +8642,26 @@ function pruneOrphanedEntries(path = manifestPath()) {
 }
 
 // dist/src/skillify/agent-roots.js
-import { existsSync as existsSync23 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { join as join31 } 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 = existsSync23(join31(home, ".codex"));
-  const piInstalled = existsSync23(join31(home, ".pi", "agent"));
-  const hermesInstalled = existsSync23(join31(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(join31(home, ".agents", "skills"));
+    out.push(join39(home, ".agents", "skills"));
   }
   if (hermesInstalled) {
-    out.push(join31(home, ".hermes", "skills"));
+    out.push(join39(home, ".hermes", "skills"));
   }
   if (piInstalled) {
-    out.push(join31(home, ".pi", "agent", "skills"));
+    out.push(join39(home, ".pi", "agent", "skills"));
   }
   return out;
 }
-function detectAgentSkillsRoots(canonicalRoot, home = homedir16()) {
+function detectAgentSkillsRoots(canonicalRoot, home = homedir17()) {
   return resolveDetected(home).filter((p) => p !== canonicalRoot);
 }
 
@@ -6851,15 +8705,15 @@ function isMissingTableError(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join32(homedir17(), ".claude", "skills");
+    return join40(homedir18(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join32(cwd, ".claude", "skills");
+  return join40(cwd, ".claude", "skills");
 }
 function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
   const out = [];
   for (const root of agentRoots) {
-    const link = join32(root, dirName);
+    const link = join40(root, dirName);
     let existing;
     try {
       existing = lstatSync5(link);
@@ -6881,13 +8735,13 @@ function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
         continue;
       }
       try {
-        unlinkSync10(link);
+        unlinkSync11(link);
       } catch {
         continue;
       }
     }
     try {
-      mkdirSync14(dirname8(link), { recursive: true });
+      mkdirSync20(dirname14(link), { recursive: true });
       symlinkSync2(canonicalDir, link, "dir");
       out.push(link);
     } catch {
@@ -6902,8 +8756,8 @@ function backfillSymlinks(installRoot) {
     return;
   const detected = detectAgentSkillsRoots(installRoot);
   for (const entry of entries) {
-    const canonical = join32(entry.installRoot, entry.dirName);
-    if (!existsSync24(canonical))
+    const canonical = join40(entry.installRoot, entry.dirName);
+    if (!existsSync30(canonical))
       continue;
     const fresh = fanOutSymlinks(canonical, entry.dirName, detected);
     if (sameSorted(fresh, entry.symlinks))
@@ -7013,10 +8867,10 @@ function renderFrontmatter2(fm) {
   return lines.join("\n");
 }
 function readLocalVersion(path) {
-  if (!existsSync24(path))
+  if (!existsSync30(path))
     return null;
   try {
-    const text = readFileSync22(path, "utf-8");
+    const text = readFileSync28(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -7111,8 +8965,8 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const skillDir2 = join32(root, dirName);
-    const skillFile = join32(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({
@@ -7123,14 +8977,14 @@ async function runPull(opts) {
     });
     let manifestError;
     if (action === "wrote") {
-      mkdirSync14(skillDir2, { recursive: true });
-      if (existsSync24(skillFile)) {
+      mkdirSync20(skillDir2, { recursive: true });
+      if (existsSync30(skillFile)) {
         try {
-          renameSync7(skillFile, `${skillFile}.bak`);
+          renameSync11(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync17(skillFile, renderSkillFile(row));
+      writeFileSync22(skillFile, renderSkillFile(row));
       const symlinks = opts.install === "global" ? fanOutSymlinks(skillDir2, dirName, detectAgentSkillsRoots(root)) : [];
       try {
         recordPull({
@@ -7172,15 +9026,15 @@ async function runPull(opts) {
 }
 
 // dist/src/skillify/unpull.js
-import { existsSync as existsSync25, readdirSync as readdirSync5, rmSync as rmSync5, statSync as statSync6 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { join as join33 } 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 join33(homedir18(), ".claude", "skills");
+    return join41(homedir19(), ".claude", "skills");
   if (!cwd)
     throw new Error("cwd required when install === 'project'");
-  return join33(cwd, ".claude", "skills");
+  return join41(cwd, ".claude", "skills");
 }
 function runUnpull(opts) {
   const root = resolveUnpullRoot(opts.install, opts.cwd);
@@ -7203,8 +9057,8 @@ function runUnpull(opts) {
   const entries = entriesForRoot(manifest, opts.install, root);
   for (const entry of entries) {
     summary.scanned++;
-    const path = join33(root, entry.dirName);
-    if (!existsSync25(path)) {
+    const path = join41(root, entry.dirName);
+    if (!existsSync31(path)) {
       if (!opts.dryRun) {
         unlinkSymlinks(entry.symlinks);
         removePullEntry(opts.install, entry.installRoot, entry.dirName);
@@ -7257,12 +9111,12 @@ function runUnpull(opts) {
     }
     summary.entries.push(result);
   }
-  if (existsSync25(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 readdirSync5(root)) {
+    for (const dirName of readdirSync6(root)) {
       if (manifestDirNames.has(dirName))
         continue;
-      const path = join33(root, dirName);
+      const path = join41(root, dirName);
       let st;
       try {
         st = statSync6(path);
@@ -7341,30 +9195,30 @@ function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
 
 // dist/src/commands/mine-local.js
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "node:fs";
-import { homedir as homedir22 } from "node:os";
-import { basename as basename2, dirname as dirname10, join as join37 } from "node:path";
+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 readdirSync6, readFileSync as readFileSync23, existsSync as existsSync26, statSync as statSync7 } from "node:fs";
-import { homedir as homedir19 } from "node:os";
-import { join as join34 } from "node:path";
-var HOME2 = homedir19();
+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 = join34(HOME2, ".claude", "projects");
-  if (existsSync26(claudeRoot)) {
+  const claudeRoot = join42(HOME2, ".claude", "projects");
+  if (existsSync32(claudeRoot)) {
     installs.push({
       agent: "claude_code",
       sessionRoot: claudeRoot,
       encodeCwd: encodeCwdClaudeCode
     });
   }
-  const codexRoot = join34(HOME2, ".codex", "sessions");
-  if (existsSync26(codexRoot)) {
+  const codexRoot = join42(HOME2, ".codex", "sessions");
+  if (existsSync32(codexRoot)) {
     installs.push({
       agent: "codex",
       sessionRoot: codexRoot,
@@ -7386,12 +9240,12 @@ function listLocalSessions(installs, cwd) {
     const cwdEncoded = install.encodeCwd(cwd);
     let subdirs = [];
     try {
-      subdirs = readdirSync6(install.sessionRoot);
+      subdirs = readdirSync7(install.sessionRoot);
     } catch {
       continue;
     }
     for (const sub of subdirs) {
-      const subdirPath = join34(install.sessionRoot, sub);
+      const subdirPath = join42(install.sessionRoot, sub);
       try {
         if (!statSync7(subdirPath).isDirectory())
           continue;
@@ -7401,14 +9255,14 @@ function listLocalSessions(installs, cwd) {
       const inCwd = sub === cwdEncoded;
       let files = [];
       try {
-        files = readdirSync6(subdirPath);
+        files = readdirSync7(subdirPath);
       } catch {
         continue;
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const fullPath = join34(subdirPath, f);
+        const fullPath = join42(subdirPath, f);
         let stats;
         try {
           stats = statSync7(fullPath);
@@ -7469,7 +9323,7 @@ function pickSessions(candidates, opts) {
 function nativeJsonlToRows(filePath, sessionId, agent) {
   let raw;
   try {
-    raw = readFileSync23(filePath, "utf-8");
+    raw = readFileSync29(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -7559,22 +9413,22 @@ function extractPairs(rows) {
 }
 
 // dist/src/skillify/gate-runner.js
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir20 } from "node:os";
-import { join as join35 } 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 (existsSync27(c))
+    if (existsSync33(c))
       return c;
   }
   return null;
 }
 function findAgentBin(agent) {
-  const home = homedir20();
+  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
@@ -7583,45 +9437,45 @@ function findAgentBin(agent) {
     // #170 caught the gap.
     case "claude_code":
       return firstExistingPath([
-        join35(home, ".claude", "local", "claude"),
+        join43(home, ".claude", "local", "claude"),
         "/usr/local/bin/claude",
         "/usr/bin/claude",
-        join35(home, ".npm-global", "bin", "claude"),
-        join35(home, ".local", "bin", "claude"),
+        join43(home, ".npm-global", "bin", "claude"),
+        join43(home, ".local", "bin", "claude"),
         "/opt/homebrew/bin/claude"
-      ]) ?? join35(home, ".claude", "local", "claude");
+      ]) ?? join43(home, ".claude", "local", "claude");
     case "codex":
       return firstExistingPath([
         "/usr/local/bin/codex",
         "/usr/bin/codex",
-        join35(home, ".npm-global", "bin", "codex"),
-        join35(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",
-        join35(home, ".npm-global", "bin", "cursor-agent"),
-        join35(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([
-        join35(home, ".local", "bin", "hermes"),
+        join43(home, ".local", "bin", "hermes"),
         "/usr/local/bin/hermes",
         "/usr/bin/hermes",
-        join35(home, ".npm-global", "bin", "hermes"),
+        join43(home, ".npm-global", "bin", "hermes"),
         "/opt/homebrew/bin/hermes"
-      ]) ?? join35(home, ".local", "bin", "hermes");
+      ]) ?? join43(home, ".local", "bin", "hermes");
     case "pi":
       return firstExistingPath([
-        join35(home, ".local", "bin", "pi"),
+        join43(home, ".local", "bin", "pi"),
         "/usr/local/bin/pi",
         "/usr/bin/pi",
-        join35(home, ".npm-global", "bin", "pi"),
+        join43(home, ".npm-global", "bin", "pi"),
         "/opt/homebrew/bin/pi"
-      ]) ?? join35(home, ".local", "bin", "pi");
+      ]) ?? join43(home, ".local", "bin", "pi");
   }
 }
 
@@ -7651,28 +9505,28 @@ function extractJsonBlock(s) {
 }
 
 // dist/src/skillify/local-manifest.js
-import { existsSync as existsSync28, mkdirSync as mkdirSync15, readFileSync as readFileSync24, writeFileSync as writeFileSync18 } from "node:fs";
-import { homedir as homedir21 } from "node:os";
-import { dirname as dirname9, join as join36 } from "node:path";
-var LOCAL_MANIFEST_PATH = join36(homedir21(), ".claude", "hivemind", "local-mined.json");
-var LOCAL_MINE_LOCK_PATH = join36(homedir21(), ".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 (!existsSync28(path))
+  if (!existsSync34(path))
     return null;
   try {
-    return JSON.parse(readFileSync24(path, "utf-8"));
+    return JSON.parse(readFileSync30(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLocalManifest(m, path = LOCAL_MANIFEST_PATH) {
-  mkdirSync15(dirname9(path), { recursive: true });
-  writeFileSync18(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 unlinkSync11 } from "node:fs";
+import { unlinkSync as unlinkSync12 } from "node:fs";
 var EPSILON = 0.3;
 var DEFAULT_N = 8;
 var PAIR_CHAR_CAP = 4e3;
@@ -7683,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((resolve3) => {
+  return new Promise((resolve6) => {
     if (opts.agent !== "claude_code") {
-      resolve3({
+      resolve6({
         stdout: "",
         stderr: "",
         errored: true,
@@ -7693,8 +9547,8 @@ function runGateViaStdin(opts) {
       });
       return;
     }
-    if (!existsSync29(opts.bin)) {
-      resolve3({
+    if (!existsSync35(opts.bin)) {
+      resolve6({
         stdout: "",
         stderr: "",
         errored: true,
@@ -7721,7 +9575,7 @@ function runGateViaStdin(opts) {
       if (settled)
         return;
       settled = true;
-      resolve3(r);
+      resolve6(r);
     };
     const timer = setTimeout(() => {
       try {
@@ -8000,7 +9854,7 @@ async function runMineLocal(args) {
       return;
     lockReleased = true;
     try {
-      unlinkSync11(LOCAL_MINE_LOCK_PATH);
+      unlinkSync12(LOCAL_MINE_LOCK_PATH);
     } catch {
     }
   };
@@ -8057,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 = join37(homedir22(), ".claude", "hivemind", `mine-local-${Date.now()}`);
-  mkdirSync16(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);
@@ -8069,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 = join37(tmpDir, `s-${shortId}`);
-    mkdirSync16(sessionTmp, { recursive: true });
-    const verdictPath = join37(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);
-    writeFileSync19(join37(sessionTmp, "prompt.txt"), prompt);
+    writeFileSync24(join45(sessionTmp, "prompt.txt"), prompt);
     const gate = await runGateViaStdin({ agent: gateAgent, bin: gateBin, prompt, timeoutMs: GATE_TIMEOUT_MS });
     try {
-      writeFileSync19(join37(sessionTmp, "gate-stdout.txt"), gate.stdout);
+      writeFileSync24(join45(sessionTmp, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync19(join37(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 = existsSync29(verdictPath) ? readFileSync25(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})`);
@@ -8137,7 +9991,7 @@ async function runMineLocalImpl(args) {
         sourceSessions: [session.sessionId],
         agent: gateAgent
       });
-      const canonicalDir = dirname10(result.path);
+      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})`);
@@ -8314,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 (!existsSync30(dir)) {
+  if (!existsSync36(dir)) {
     console.log(`state: (no projects tracked yet)`);
     return;
   }
-  const files = readdirSync7(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;
@@ -8326,7 +10180,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync26(join38(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})`);
@@ -8353,7 +10207,7 @@ function setInstall(loc) {
   }
   const cfg = loadScopeConfig();
   saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join38(homedir23(), ".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) {
@@ -8361,18 +10215,18 @@ function promoteSkill(name, cwd) {
     console.error("Usage: hivemind skillify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join38(cwd, ".claude", "skills", name);
-  const globalPath = join38(homedir23(), ".claude", "skills", name);
-  if (!existsSync30(join38(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 (existsSync30(join38(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);
   }
-  mkdirSync17(dirname11(globalPath), { recursive: true });
-  renameSync8(projectPath, globalPath);
+  mkdirSync23(dirname17(globalPath), { recursive: true });
+  renameSync12(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
 function teamAdd(name) {
@@ -8478,7 +10332,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join38(homedir23(), ".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" : ""}`);
@@ -8528,7 +10382,7 @@ async function unpullSkills(args) {
     all,
     legacyCleanup
   });
-  const dest = toRaw === "global" ? join38(homedir23(), ".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(",")}`);
@@ -8623,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 closeSync3, existsSync as existsSync31, mkdirSync as mkdirSync18, openSync as openSync3, readFileSync as readFileSync28, realpathSync, unlinkSync as unlinkSync12, writeSync as writeSync2 } from "node:fs";
-import { homedir as homedir24 } from "node:os";
-import { dirname as dirname13, join as join40, 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 readFileSync27 } from "node:fs";
-import { dirname as dirname12, join as join39 } 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);
@@ -8643,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 join40(homedir24(), ".deeplake", "hivemind-update.lock");
+  return join48(homedir25(), ".deeplake", "hivemind-update.lock");
 }
 function detectInstallKind(argv1) {
   const realArgv1 = (() => {
@@ -8653,36 +10507,36 @@ function detectInstallKind(argv1) {
       return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
     }
   })();
-  let dir = dirname13(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(readFileSync28(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 = dirname13(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  installDir ??= dirname13(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 (existsSync31(`${gitDir}${sep}.git`)) {
+    if (existsSync37(`${gitDir}${sep2}.git`)) {
       return { kind: "local-dev", installDir };
     }
-    const parent = dirname13(gitDir);
+    const parent = dirname19(gitDir);
     if (parent === gitDir)
       break;
     gitDir = parent;
@@ -8701,10 +10555,10 @@ async function getLatestNpmVersion(timeoutMs = 5e3) {
   }
 }
 var defaultSpawn = (cmd, args) => {
-  execFileSync4(cmd, args, { stdio: "inherit" });
+  execFileSync6(cmd, args, { stdio: "inherit" });
 };
 function tryAcquireLock(path) {
-  mkdirSync18(dirname13(path), { recursive: true, mode: 448 });
+  mkdirSync24(dirname19(path), { recursive: true, mode: 448 });
   const claim = () => {
     const fd = openSync3(path, "wx", 384);
     writeSync2(fd, String(process.pid));
@@ -8718,7 +10572,7 @@ function tryAcquireLock(path) {
   }
   let holderPid = 0;
   try {
-    holderPid = Number(readFileSync28(path, "utf-8").trim()) || 0;
+    holderPid = Number(readFileSync34(path, "utf-8").trim()) || 0;
   } catch {
     try {
       return claim();
@@ -8735,7 +10589,7 @@ function tryAcquireLock(path) {
     }
   }
   try {
-    unlinkSync12(path);
+    unlinkSync13(path);
   } catch {
   }
   try {
@@ -8751,7 +10605,7 @@ function releaseLock(fd, path) {
   } catch {
   }
   try {
-    unlinkSync12(path);
+    unlinkSync13(path);
   } catch {
   }
 }
@@ -8857,7 +10711,7 @@ var AUTH_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "autoupdate",
   "sessions"
 ]);
-var USAGE2 = `
+var USAGE3 = `
 hivemind \u2014 one brain for every agent on your team
 
 Usage:
@@ -8927,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()}
 
@@ -9117,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(USAGE2);
+    log(USAGE3);
     return;
   }
   if (cmd === "--version" || cmd === "-v" || cmd === "version") {
@@ -9151,6 +11021,10 @@ 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);
@@ -9202,7 +11076,7 @@ async function main() {
     return;
   }
   warn(`Unknown command: ${cmd}`);
-  log(USAGE2);
+  log(USAGE3);
   process.exit(1);
 }
 main().catch((err) => {