@deeplake/hivemind 0.7.75 → 0.7.77

package/hermes/bundle/graph-on-stop.js

@@ -0,0 +1,3148 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/src/index-marker-store.js
+var index_marker_store_exports = {};
+__export(index_marker_store_exports, {
+  buildIndexMarkerPath: () => buildIndexMarkerPath,
+  getIndexMarkerDir: () => getIndexMarkerDir,
+  hasFreshIndexMarker: () => hasFreshIndexMarker,
+  writeIndexMarker: () => writeIndexMarker
+});
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+import { tmpdir } from "node:os";
+function getIndexMarkerDir() {
+  return process.env.HIVEMIND_INDEX_MARKER_DIR ?? join8(tmpdir(), "hivemind-deeplake-indexes");
+}
+function buildIndexMarkerPath(workspaceId, orgId, table, suffix) {
+  const markerKey = [workspaceId, orgId, table, suffix].join("__").replace(/[^a-zA-Z0-9_.-]/g, "_");
+  return join8(getIndexMarkerDir(), `${markerKey}.json`);
+}
+function hasFreshIndexMarker(markerPath) {
+  if (!existsSync4(markerPath))
+    return false;
+  try {
+    const raw = JSON.parse(readFileSync7(markerPath, "utf-8"));
+    const updatedAt = raw.updatedAt ? new Date(raw.updatedAt).getTime() : NaN;
+    if (!Number.isFinite(updatedAt) || Date.now() - updatedAt > INDEX_MARKER_TTL_MS)
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeIndexMarker(markerPath) {
+  mkdirSync5(getIndexMarkerDir(), { recursive: true });
+  writeFileSync5(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
+}
+var INDEX_MARKER_TTL_MS;
+var init_index_marker_store = __esm({
+  "dist/src/index-marker-store.js"() {
+    "use strict";
+    INDEX_MARKER_TTL_MS = Number(process.env.HIVEMIND_INDEX_MARKER_TTL_MS ?? 6 * 60 * 6e4);
+  }
+});
+
+// dist/src/hooks/graph-on-stop.js
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { createHash as createHash7 } from "node:crypto";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync13 } from "node:fs";
+import { join as join18 } from "node:path";
+
+// dist/src/commands/graph.js
+import { execSync as execSync2 } from "node:child_process";
+import { readFileSync as readFileSync13, readdirSync } from "node:fs";
+import { join as join16, relative, resolve as resolve4, sep } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+
+// dist/src/cli/version.js
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// dist/src/cli/util.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, symlinkSync, unlinkSync, lstatSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+var HOME = homedir();
+function pkgRoot() {
+  let dir = fileURLToPath(new URL(".", import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+      if (pkg.name === "@deeplake/hivemind" || pkg.name === "hivemind")
+        return dir;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return fileURLToPath(new URL("..", import.meta.url));
+}
+var PLATFORM_MARKERS = [
+  { id: "claude", markerDir: join(HOME, ".claude") },
+  { id: "codex", markerDir: join(HOME, ".codex") },
+  { id: "claw", markerDir: join(HOME, ".openclaw") },
+  { id: "cursor", markerDir: join(HOME, ".cursor") },
+  { id: "hermes", markerDir: join(HOME, ".hermes") },
+  // pi (badlogic/pi-mono coding-agent) — config at ~/.pi/agent/. pi exposes
+  // a rich extension event API (session_start / input / tool_call /
+  // tool_result / message_end / session_shutdown / etc.) — Tier 1 capable.
+  { id: "pi", markerDir: join(HOME, ".pi") }
+];
+
+// dist/src/cli/version.js
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync2(join2(pkgRoot(), "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// dist/src/graph/cache.js
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+var CACHE_SCHEMA_VERSION = 1;
+function fileContentHash(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+function cacheDir(baseDir) {
+  return join3(baseDir, ".cache");
+}
+function cachePath(baseDir, contentSha256) {
+  return join3(cacheDir(baseDir), `${contentSha256}.json`);
+}
+function readCache(baseDir, contentSha256, relativePath) {
+  const path = cachePath(baseDir, contentSha256);
+  if (!existsSync2(path))
+    return null;
+  let raw;
+  try {
+    raw = readFileSync3(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 {
+    mkdirSync2(dirname2(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync2(tmp, JSON.stringify(entry));
+    renameSync(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";
+
+// dist/src/config.js
+import { readFileSync as readFileSync4, existsSync as existsSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+import { homedir as homedir2, userInfo } from "node:os";
+function loadConfig() {
+  const home = homedir2();
+  const credPath = join4(home, ".deeplake", "credentials.json");
+  let creds = null;
+  if (existsSync3(credPath)) {
+    try {
+      creds = JSON.parse(readFileSync4(credPath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  const token = process.env.HIVEMIND_TOKEN ?? creds?.token;
+  const orgId = process.env.HIVEMIND_ORG_ID ?? creds?.orgId;
+  if (!token || !orgId)
+    return null;
+  return {
+    token,
+    orgId,
+    orgName: creds?.orgName ?? orgId,
+    userName: creds?.userName || userInfo().username || "unknown",
+    workspaceId: process.env.HIVEMIND_WORKSPACE_ID ?? creds?.workspaceId ?? "default",
+    apiUrl: process.env.HIVEMIND_API_URL ?? creds?.apiUrl ?? "https://api.deeplake.ai",
+    tableName: process.env.HIVEMIND_TABLE ?? "memory",
+    sessionsTableName: process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions",
+    skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    // Defaults match the table name written into the SQL — keep aligned
+    // with RULES_COLUMNS in deeplake-schema.ts and with the e2e test-org
+    // override convention (memory_test / sessions_test → goals_test, etc.)
+    // documented in CLAUDE.md.
+    rulesTableName: process.env.HIVEMIND_RULES_TABLE ?? "hivemind_rules",
+    // Goals + KPIs (refined design — VFS path classifier maps
+    //   memory/goal/<user>/<status>/<uuid>.md → hivemind_goals row
+    //   memory/kpi/<uuid>/<kpi_id>.md → hivemind_kpis row
+    // See src/shell/deeplake-fs.ts for the translation logic and
+    // GOALS_COLUMNS / KPIS_COLUMNS in deeplake-schema.ts for the
+    // table shape.
+    goalsTableName: process.env.HIVEMIND_GOALS_TABLE ?? "hivemind_goals",
+    kpisTableName: process.env.HIVEMIND_KPIS_TABLE ?? "hivemind_kpis",
+    codebaseTableName: process.env.HIVEMIND_CODEBASE_TABLE ?? "codebase",
+    memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join4(home, ".deeplake", "memory")
+  };
+}
+
+// dist/src/deeplake-api.js
+import { randomUUID } from "node:crypto";
+
+// dist/src/utils/debug.js
+import { appendFileSync } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var LOG = join5(homedir3(), ".deeplake", "hook-debug.log");
+function isDebug() {
+  return process.env.HIVEMIND_DEBUG === "1";
+}
+function log(tag, msg) {
+  if (!isDebug())
+    return;
+  appendFileSync(LOG, `${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${msg}
+`);
+}
+
+// dist/src/utils/sql.js
+function sqlStr(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/\0/g, "").replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+function sqlIdent(name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${JSON.stringify(name)}`);
+  }
+  return name;
+}
+
+// dist/src/embeddings/columns.js
+var SUMMARY_EMBEDDING_COL = "summary_embedding";
+
+// dist/src/utils/client-header.js
+var DEEPLAKE_CLIENT_HEADER = "X-Deeplake-Client";
+function deeplakeClientValue() {
+  return "hivemind";
+}
+function deeplakeClientHeader() {
+  return { [DEEPLAKE_CLIENT_HEADER]: deeplakeClientValue() };
+}
+
+// dist/src/deeplake-schema.js
+var MEMORY_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "path", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "filename", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "summary", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "summary_embedding", sql: "FLOAT4[]" },
+  { name: "author", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "mime_type", sql: "TEXT NOT NULL DEFAULT 'text/plain'" },
+  { name: "size_bytes", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "project", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "description", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "creation_date", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "last_update_date", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var SESSIONS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "path", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "filename", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "message", sql: "JSONB" },
+  { name: "message_embedding", sql: "FLOAT4[]" },
+  { name: "author", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "mime_type", sql: "TEXT NOT NULL DEFAULT 'application/json'" },
+  { name: "size_bytes", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "project", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "description", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "creation_date", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "last_update_date", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var SKILLS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "name", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "project", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "project_key", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "local_path", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "install", sql: "TEXT NOT NULL DEFAULT 'project'" },
+  { name: "source_sessions", sql: "TEXT NOT NULL DEFAULT '[]'" },
+  { name: "source_agent", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'me'" },
+  { name: "author", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "contributors", sql: "TEXT NOT NULL DEFAULT '[]'" },
+  { name: "description", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "trigger_text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "body", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var RULES_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "rule_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'team'" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'active'" },
+  { name: "assigned_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var GOALS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "owner", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'opened'" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var KPIS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "kpi_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+function validateSchema(label, cols) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const col of cols) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(col.name)) {
+      throw new Error(`${label}: column name "${col.name}" is not a valid SQL identifier`);
+    }
+    if (seen.has(col.name)) {
+      throw new Error(`${label}: duplicate column "${col.name}"`);
+    }
+    seen.add(col.name);
+    const notNull = /\bNOT\s+NULL\b/i.test(col.sql);
+    const hasDefault = /\bDEFAULT\b/i.test(col.sql);
+    if (notNull && !hasDefault) {
+      throw new Error(`${label}: column "${col.name}" is NOT NULL but has no DEFAULT \u2014 ALTER TABLE ADD COLUMN on a populated table would fail.`);
+    }
+  }
+}
+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("RULES_COLUMNS", RULES_COLUMNS);
+validateSchema("GOALS_COLUMNS", GOALS_COLUMNS);
+validateSchema("KPIS_COLUMNS", KPIS_COLUMNS);
+validateSchema("CODEBASE_COLUMNS", CODEBASE_COLUMNS);
+function buildCreateTableSql(tableName, cols) {
+  const safe = sqlIdent(tableName);
+  const colSql = cols.map((c) => `${c.name} ${c.sql}`).join(", ");
+  return `CREATE TABLE IF NOT EXISTS "${safe}" (${colSql}) USING deeplake`;
+}
+function buildIntrospectionSql(tableName, workspaceId) {
+  return `SELECT column_name FROM information_schema.columns WHERE table_name = '${sqlStr(tableName)}' AND table_schema = '${sqlStr(workspaceId)}'`;
+}
+async function healMissingColumns(args) {
+  const safeTable = sqlIdent(args.tableName);
+  const introspectSql = buildIntrospectionSql(args.tableName, args.workspaceId);
+  const rows = await args.query(introspectSql);
+  const existing = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const v = row?.column_name;
+    if (typeof v === "string")
+      existing.add(v.toLowerCase());
+  }
+  const missingCols = args.columns.filter((c) => !existing.has(c.name.toLowerCase()));
+  const missing = missingCols.map((c) => c.name);
+  if (missingCols.length === 0)
+    return { missing, altered: [] };
+  const altered = [];
+  for (const col of missingCols) {
+    try {
+      await args.query(`ALTER TABLE "${safeTable}" ADD COLUMN ${col.name} ${col.sql}`);
+      altered.push(col.name);
+      args.log?.(`schema-heal: added "${args.tableName}"."${col.name}"`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!/already exists/i.test(msg))
+        throw e;
+      const recheck = await args.query(introspectSql);
+      const present = recheck.some((r) => {
+        const v = r?.column_name;
+        return typeof v === "string" && v.toLowerCase() === col.name.toLowerCase();
+      });
+      if (!present)
+        throw e;
+      args.log?.(`schema-heal: "${args.tableName}"."${col.name}" appeared via race, treating as success`);
+    }
+  }
+  return { missing, altered };
+}
+
+// dist/src/notifications/queue.js
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync as renameSync2, mkdirSync as mkdirSync3, openSync, closeSync, unlinkSync as unlinkSync2, statSync } from "node:fs";
+import { join as join6, resolve } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { setTimeout as sleep } from "node:timers/promises";
+var log2 = (msg) => log("notifications-queue", msg);
+var LOCK_RETRY_MAX = 50;
+var LOCK_RETRY_BASE_MS = 5;
+var LOCK_STALE_MS = 5e3;
+function queuePath() {
+  return join6(homedir4(), ".deeplake", "notifications-queue.json");
+}
+function lockPath() {
+  return `${queuePath()}.lock`;
+}
+function readQueue() {
+  try {
+    const raw = readFileSync5(queuePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.queue)) {
+      log2(`queue malformed \u2192 treating as empty`);
+      return { queue: [] };
+    }
+    return { queue: parsed.queue };
+  } catch {
+    return { queue: [] };
+  }
+}
+function _isQueuePathInsideHome(path, home) {
+  const r = resolve(path);
+  const h = resolve(home);
+  return r.startsWith(h + "/") || r === h;
+}
+function writeQueue(q) {
+  const path = queuePath();
+  const home = resolve(homedir4());
+  if (!_isQueuePathInsideHome(path, home)) {
+    throw new Error(`notifications-queue write blocked: ${path} is outside ${home}`);
+  }
+  mkdirSync3(join6(home, ".deeplake"), { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(q, null, 2), { mode: 384 });
+  renameSync2(tmp, path);
+}
+async function withQueueLock(fn) {
+  const path = lockPath();
+  mkdirSync3(join6(homedir4(), ".deeplake"), { recursive: true, mode: 448 });
+  let fd = null;
+  for (let attempt = 0; attempt < LOCK_RETRY_MAX; attempt++) {
+    try {
+      fd = openSync(path, "wx", 384);
+      break;
+    } catch (e) {
+      const code = e.code;
+      if (code !== "EEXIST")
+        throw e;
+      try {
+        const age = Date.now() - statSync(path).mtimeMs;
+        if (age > LOCK_STALE_MS) {
+          unlinkSync2(path);
+          continue;
+        }
+      } catch {
+      }
+      const delay = LOCK_RETRY_BASE_MS * (attempt + 1);
+      await sleep(delay);
+    }
+  }
+  if (fd === null) {
+    log2(`lock acquisition gave up after ${LOCK_RETRY_MAX} attempts \u2014 proceeding unlocked (last-writer-wins)`);
+    return fn();
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+    try {
+      unlinkSync2(path);
+    } catch {
+    }
+  }
+}
+function sameDedupKey(a, b) {
+  if (a.id !== b.id)
+    return false;
+  return JSON.stringify(a.dedupKey) === JSON.stringify(b.dedupKey);
+}
+async function enqueueNotification(n) {
+  await withQueueLock(() => {
+    const q = readQueue();
+    if (q.queue.some((existing) => sameDedupKey(existing, n))) {
+      return;
+    }
+    q.queue.push(n);
+    writeQueue(q);
+  });
+}
+
+// dist/src/commands/auth-creds.js
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+function configDir() {
+  return join7(homedir5(), ".deeplake");
+}
+function credsPath() {
+  return join7(configDir(), "credentials.json");
+}
+function loadCredentials() {
+  try {
+    return JSON.parse(readFileSync6(credsPath(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// dist/src/deeplake-api.js
+var indexMarkerStorePromise = null;
+function getIndexMarkerStore() {
+  if (!indexMarkerStorePromise)
+    indexMarkerStorePromise = Promise.resolve().then(() => (init_index_marker_store(), index_marker_store_exports));
+  return indexMarkerStorePromise;
+}
+var log3 = (msg) => log("sdk", msg);
+function summarizeSql(sql, maxLen = 220) {
+  const compact = sql.replace(/\s+/g, " ").trim();
+  return compact.length > maxLen ? `${compact.slice(0, maxLen)}...` : compact;
+}
+function traceSql(msg) {
+  const traceEnabled = process.env.HIVEMIND_TRACE_SQL === "1" || process.env.HIVEMIND_DEBUG === "1";
+  if (!traceEnabled)
+    return;
+  process.stderr.write(`[deeplake-sql] ${msg}
+`);
+  if (process.env.HIVEMIND_DEBUG === "1")
+    log3(msg);
+}
+var _signalledBalanceExhausted = false;
+function maybeSignalBalanceExhausted(status, bodyText) {
+  if (status !== 402)
+    return;
+  if (!bodyText.includes("balance_cents"))
+    return;
+  if (_signalledBalanceExhausted)
+    return;
+  _signalledBalanceExhausted = true;
+  log3(`balance exhausted \u2014 enqueuing session-start banner (body=${bodyText.slice(0, 120)})`);
+  enqueueNotification({
+    id: "balance-exhausted",
+    severity: "warn",
+    transient: true,
+    title: "Hivemind credits exhausted \u2014 top up to keep capturing",
+    body: `Sessions are not being saved and memory recall is returning empty. Top up at ${billingUrl()} to restore capture and recall.`,
+    dedupKey: { reason: "balance-zero" },
+    // User-facing billing notice → user channel only. Never the model's
+    // additionalContext: a "top up at <url>" instruction in the agent prompt
+    // is a prompt-injection pattern external agents flag.
+    userVisibleOnly: true
+  }).catch((e) => {
+    log3(`enqueue balance-exhausted failed: ${e instanceof Error ? e.message : String(e)}`);
+  });
+}
+function billingUrl() {
+  try {
+    const c = loadCredentials();
+    if (c?.orgName && c?.workspaceId) {
+      return `https://deeplake.ai/${encodeURIComponent(c.orgName)}/workspace/${encodeURIComponent(c.workspaceId)}/billing`;
+    }
+  } catch {
+  }
+  return "https://deeplake.ai";
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 500;
+var MAX_CONCURRENCY = 5;
+function getQueryTimeoutMs() {
+  return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
+}
+function sleep2(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+function isTimeoutError(error) {
+  const name = error instanceof Error ? error.name.toLowerCase() : "";
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return name.includes("timeout") || name === "aborterror" || message.includes("timeout") || message.includes("timed out");
+}
+function isDuplicateIndexError(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return message.includes("duplicate key value violates unique constraint") || message.includes("pg_class_relname_nsp_index") || message.includes("already exists");
+}
+function isSessionInsertQuery(sql) {
+  return /^\s*insert\s+into\s+"[^"]+"\s*\(\s*id\s*,\s*path\s*,\s*filename\s*,\s*message\s*,/i.test(sql);
+}
+function isTransientHtml403(text) {
+  const body = text.toLowerCase();
+  return body.includes("<html") || body.includes("403 forbidden") || body.includes("cloudflare") || body.includes("nginx");
+}
+var Semaphore = class {
+  max;
+  waiting = [];
+  active = 0;
+  constructor(max) {
+    this.max = max;
+  }
+  async acquire() {
+    if (this.active < this.max) {
+      this.active++;
+      return;
+    }
+    await new Promise((resolve6) => this.waiting.push(resolve6));
+  }
+  release() {
+    this.active--;
+    const next = this.waiting.shift();
+    if (next) {
+      this.active++;
+      next();
+    }
+  }
+};
+var DeeplakeApi = class {
+  token;
+  apiUrl;
+  orgId;
+  workspaceId;
+  tableName;
+  _pendingRows = [];
+  _sem = new Semaphore(MAX_CONCURRENCY);
+  _tablesCache = null;
+  constructor(token, apiUrl, orgId, workspaceId, tableName) {
+    this.token = token;
+    this.apiUrl = apiUrl;
+    this.orgId = orgId;
+    this.workspaceId = workspaceId;
+    this.tableName = tableName;
+  }
+  /** Execute SQL with retry on transient errors and bounded concurrency. */
+  async query(sql) {
+    const startedAt = Date.now();
+    const summary = summarizeSql(sql);
+    traceSql(`query start: ${summary}`);
+    await this._sem.acquire();
+    try {
+      const rows = await this._queryWithRetry(sql);
+      traceSql(`query ok (${Date.now() - startedAt}ms, rows=${rows.length}): ${summary}`);
+      return rows;
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      traceSql(`query fail (${Date.now() - startedAt}ms): ${summary} :: ${message}`);
+      throw e;
+    } finally {
+      this._sem.release();
+    }
+  }
+  async _queryWithRetry(sql) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      let resp;
+      const timeoutMs = getQueryTimeoutMs();
+      try {
+        const signal = AbortSignal.timeout(timeoutMs);
+        resp = await fetch(`${this.apiUrl}/workspaces/${this.workspaceId}/tables/query`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+            "X-Activeloop-Org-Id": this.orgId,
+            ...deeplakeClientHeader()
+          },
+          signal,
+          body: JSON.stringify({ query: sql })
+        });
+      } catch (e) {
+        if (isTimeoutError(e)) {
+          lastError = new Error(`Query timeout after ${timeoutMs}ms`);
+          throw lastError;
+        }
+        lastError = e instanceof Error ? e : new Error(String(e));
+        if (attempt < MAX_RETRIES) {
+          const delay = BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 200;
+          log3(`query retry ${attempt + 1}/${MAX_RETRIES} (fetch error: ${lastError.message}) in ${delay.toFixed(0)}ms`);
+          await sleep2(delay);
+          continue;
+        }
+        throw lastError;
+      }
+      if (resp.ok) {
+        const raw = await resp.json();
+        if (!raw?.rows || !raw?.columns)
+          return [];
+        return raw.rows.map((row) => Object.fromEntries(raw.columns.map((col, i) => [col, row[i]])));
+      }
+      const text = await resp.text().catch(() => "");
+      const retryable403 = isSessionInsertQuery(sql) && (resp.status === 401 || resp.status === 403 && (text.length === 0 || isTransientHtml403(text)));
+      const alreadyExists = resp.status === 500 && isDuplicateIndexError(text);
+      if (!alreadyExists && attempt < MAX_RETRIES && (RETRYABLE_CODES.has(resp.status) || retryable403)) {
+        const delay = BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 200;
+        log3(`query retry ${attempt + 1}/${MAX_RETRIES} (${resp.status}) in ${delay.toFixed(0)}ms`);
+        await sleep2(delay);
+        continue;
+      }
+      maybeSignalBalanceExhausted(resp.status, text);
+      throw new Error(`Query failed: ${resp.status}: ${text.slice(0, 200)}`);
+    }
+    throw lastError ?? new Error("Query failed: max retries exceeded");
+  }
+  // ── Writes ──────────────────────────────────────────────────────────────────
+  /** Queue rows for writing. Call commit() to flush. */
+  appendRows(rows) {
+    this._pendingRows.push(...rows);
+  }
+  /** Flush pending rows via SQL. */
+  async commit() {
+    if (this._pendingRows.length === 0)
+      return;
+    const rows = this._pendingRows;
+    this._pendingRows = [];
+    const CONCURRENCY = 10;
+    for (let i = 0; i < rows.length; i += CONCURRENCY) {
+      const chunk = rows.slice(i, i + CONCURRENCY);
+      await Promise.allSettled(chunk.map((r) => this.upsertRowSql(r)));
+    }
+    log3(`commit: ${rows.length} rows`);
+  }
+  async upsertRowSql(row) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const cd = row.creationDate ?? ts;
+    const lud = row.lastUpdateDate ?? ts;
+    const exists = await this.query(`SELECT path FROM "${this.tableName}" WHERE path = '${sqlStr(row.path)}' LIMIT 1`);
+    if (exists.length > 0) {
+      let setClauses = `summary = E'${sqlStr(row.contentText)}', ${SUMMARY_EMBEDDING_COL} = NULL, mime_type = '${sqlStr(row.mimeType)}', size_bytes = ${row.sizeBytes}, last_update_date = '${lud}'`;
+      if (row.project !== void 0)
+        setClauses += `, project = '${sqlStr(row.project)}'`;
+      if (row.description !== void 0)
+        setClauses += `, description = '${sqlStr(row.description)}'`;
+      await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(row.path)}'`);
+    } else {
+      const id = randomUUID();
+      let cols = `id, path, filename, summary, ${SUMMARY_EMBEDDING_COL}, mime_type, size_bytes, creation_date, last_update_date`;
+      let vals = `'${id}', '${sqlStr(row.path)}', '${sqlStr(row.filename)}', E'${sqlStr(row.contentText)}', NULL, '${sqlStr(row.mimeType)}', ${row.sizeBytes}, '${cd}', '${lud}'`;
+      if (row.project !== void 0) {
+        cols += ", project";
+        vals += `, '${sqlStr(row.project)}'`;
+      }
+      if (row.description !== void 0) {
+        cols += ", description";
+        vals += `, '${sqlStr(row.description)}'`;
+      }
+      await this.query(`INSERT INTO "${this.tableName}" (${cols}) VALUES (${vals})`);
+    }
+  }
+  /** Update specific columns on a row by path. */
+  async updateColumns(path, columns) {
+    const setClauses = Object.entries(columns).map(([col, val]) => typeof val === "number" ? `${col} = ${val}` : `${col} = '${sqlStr(String(val))}'`).join(", ");
+    await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(path)}'`);
+  }
+  // ── Convenience ─────────────────────────────────────────────────────────────
+  /** Create a BM25 search index on a column. */
+  async createIndex(column) {
+    await this.query(`CREATE INDEX IF NOT EXISTS idx_${sqlStr(column)}_bm25 ON "${this.tableName}" USING deeplake_index ("${column}")`);
+  }
+  buildLookupIndexName(table, suffix) {
+    return `idx_${table}_${suffix}`.replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+  async ensureLookupIndex(table, suffix, columnsSql) {
+    const markers = await getIndexMarkerStore();
+    const markerPath = markers.buildIndexMarkerPath(this.workspaceId, this.orgId, table, suffix);
+    if (markers.hasFreshIndexMarker(markerPath))
+      return;
+    const indexName = this.buildLookupIndexName(table, suffix);
+    try {
+      await this.query(`CREATE INDEX IF NOT EXISTS "${indexName}" ON "${table}" ${columnsSql}`);
+      markers.writeIndexMarker(markerPath);
+    } catch (e) {
+      if (isDuplicateIndexError(e)) {
+        markers.writeIndexMarker(markerPath);
+        return;
+      }
+      log3(`index "${indexName}" skipped: ${e.message}`);
+    }
+  }
+  /**
+   * Heal any missing columns on a table so it matches one of the schema
+   * definitions in `deeplake-schema.ts`. One SELECT against
+   * `information_schema.columns` per call, then `ALTER TABLE ADD COLUMN`
+   * only the genuinely missing ones — never blanket, never `IF NOT
+   * EXISTS`.
+   *
+   * History: an earlier path used a local marker file (`col_<name>` under
+   * the index-marker dir) to skip even the SELECT after the first
+   * confirmation, plus per-column ALTERs for `summary_embedding`,
+   * `message_embedding`, `agent`, `plugin_version`. The marker existed
+   * because Deeplake used to expose a ~30s post-ALTER bug where
+   * subsequent INSERTs failed, so we wanted to keep ALTER traffic to a
+   * minimum. The bug was re-verified on 2026-05-18 against
+   * `api.deeplake.ai` (`test_plugin` org) and no longer reproduces
+   * (71/71 INSERTs OK, first success 2ms after ALTER). The single SELECT
+   * + targeted ALTER pattern survives the marker removal because: each
+   * ALTER still costs ~800ms (so blanket sweeps are wasteful) and the
+   * diff produces clearer logs than "ALTER all with IF NOT EXISTS".
+   */
+  async healSchema(table, columns) {
+    await healMissingColumns({
+      query: (sql) => this.query(sql),
+      tableName: table,
+      workspaceId: this.workspaceId,
+      columns,
+      log: log3
+    });
+  }
+  /** List all tables in the workspace (with retry). */
+  async listTables(forceRefresh = false) {
+    if (!forceRefresh && this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (cacheable)
+      this._tablesCache = [...tables];
+    return tables;
+  }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
+  async _fetchTables() {
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const resp = await fetch(`${this.apiUrl}/workspaces/${this.workspaceId}/tables`, {
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            "X-Activeloop-Org-Id": this.orgId,
+            ...deeplakeClientHeader()
+          }
+        });
+        if (resp.ok) {
+          const data = await resp.json();
+          return {
+            tables: (data.tables ?? []).map((t) => t.table_name),
+            cacheable: true
+          };
+        }
+        if (attempt < MAX_RETRIES && RETRYABLE_CODES.has(resp.status)) {
+          await sleep2(BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 200);
+          continue;
+        }
+        return { tables: [], cacheable: false };
+      } catch {
+        if (attempt < MAX_RETRIES) {
+          await sleep2(BASE_DELAY_MS * Math.pow(2, attempt));
+          continue;
+        }
+        return { tables: [], cacheable: false };
+      }
+    }
+    return { tables: [], cacheable: false };
+  }
+  /**
+   * Run a `CREATE TABLE` with an extra outer retry budget. The base
+   * `query()` already retries 3 times on fetch errors (~3.5s total), but a
+   * failed CREATE is permanent corruption — every subsequent SELECT against
+   * the missing table fails. Wrapping in an outer loop with longer backoff
+   * (2s, 5s, then 10s) gives us ~17s of reach across transient network
+   * blips before giving up. Failures still propagate; getApi() resets its
+   * cache on init failure (openclaw plugin) so the next call retries the
+   * whole init flow.
+   */
+  async createTableWithRetry(sql, label) {
+    const OUTER_BACKOFFS_MS = [2e3, 5e3, 1e4];
+    let lastErr = null;
+    for (let attempt = 0; attempt <= OUTER_BACKOFFS_MS.length; attempt++) {
+      try {
+        await this.query(sql);
+        return;
+      } catch (err) {
+        lastErr = err;
+        const msg = err instanceof Error ? err.message : String(err);
+        log3(`CREATE TABLE "${label}" attempt ${attempt + 1}/${OUTER_BACKOFFS_MS.length + 1} failed: ${msg}`);
+        if (attempt < OUTER_BACKOFFS_MS.length) {
+          await sleep2(OUTER_BACKOFFS_MS[attempt]);
+        }
+      }
+    }
+    throw lastErr;
+  }
+  /** Create the memory table if it doesn't already exist. Heal missing columns on existing tables. */
+  async ensureTable(name) {
+    if (!MEMORY_COLUMNS.some((c) => c.name === SUMMARY_EMBEDDING_COL)) {
+      throw new Error(`MEMORY_COLUMNS missing "${SUMMARY_EMBEDDING_COL}" (embeddings/columns.ts drift)`);
+    }
+    const tbl = sqlIdent(name ?? this.tableName);
+    const tables = await this.listTables();
+    if (!tables.includes(tbl)) {
+      log3(`table "${tbl}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(tbl, MEMORY_COLUMNS), tbl);
+      log3(`table "${tbl}" created`);
+      if (!tables.includes(tbl))
+        this._tablesCache = [...tables, tbl];
+    }
+    await this.healSchema(tbl, MEMORY_COLUMNS);
+  }
+  /** Create the sessions table (uses JSONB for message since every row is a JSON event). */
+  async ensureSessionsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, SESSIONS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, SESSIONS_COLUMNS);
+    await this.ensureLookupIndex(safe, "path_creation_date", `("path", "creation_date")`);
+  }
+  /**
+   * Create the skills table.
+   *
+   * One row per skill version. Workers INSERT a fresh row on every KEEP /
+   * MERGE rather than UPDATE-ing in place, so the full version history is
+   * recoverable. Uniqueness in the *current* state is by (project_key, name)
+   * — newer rows shadow older ones at read time (ORDER BY version DESC).
+   * 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)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, CODEBASE_COLUMNS), safe);
+      log3(`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();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, SKILLS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, SKILLS_COLUMNS);
+    await this.ensureLookupIndex(safe, "project_key_name", `("project_key", "name")`);
+  }
+  /**
+   * Create the rules table.
+   *
+   * One row per rule version (same write pattern as skills): edits INSERT
+   * a fresh row with version+1, reads pick latest per rule_id via
+   * `ORDER BY version DESC LIMIT 1`. Sidesteps the Deeplake
+   * UPDATE-coalescing quirk by never UPDATEing.
+   */
+  async ensureRulesTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, RULES_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, RULES_COLUMNS);
+    await this.ensureLookupIndex(safe, "rule_id_version", `("rule_id", "version")`);
+  }
+  /**
+   * Create the goals table.
+   *
+   * Backed by the VFS path convention memory/goal/<owner>/<status>/<goal_id>.md.
+   * INSERT-only version-bumped: rm and mv operations translate to fresh
+   * v=N+1 rows (status flips for mv → closed; rm is the same soft-close).
+   * The (goal_id, version) index lets the VFS dispatch a cheap latest-row
+   * read on cat / Read of a single goal.
+   */
+  async ensureGoalsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, GOALS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, GOALS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_version", `("goal_id", "version")`);
+    await this.ensureLookupIndex(safe, "owner_status", `("owner", "status")`);
+  }
+  /**
+   * Create the kpis table.
+   *
+   * Backed by memory/kpi/<goal_id>/<kpi_id>.md. KPI rows do NOT carry
+   * owner — ownership derives from the parent goal via logical join on
+   * goal_id. INSERT-only version-bumped. (goal_id, kpi_id) index is the
+   * canonical lookup the VFS uses on Read and Write.
+   */
+  async ensureKpisTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, KPIS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, KPIS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_kpi_id", `("goal_id", "kpi_id")`);
+  }
+};
+
+// dist/src/graph/deeplake-push.js
+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 } from "node:child_process";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname6, join as join12 } from "node:path";
+
+// dist/src/utils/repo-identity.js
+import { execSync } 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 = execSync("git config --get remote.origin.url", {
+      cwd: absCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? absCwd;
+  const key = createHash3("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/graph/last-build.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname3, join as join9 } from "node:path";
+function lastBuildPath(baseDir, worktreeId) {
+  if (worktreeId !== void 0) {
+    return join9(baseDir, "worktrees", worktreeId, ".last-build.json");
+  }
+  return join9(baseDir, ".last-build.json");
+}
+function writeLastBuild(baseDir, state, worktreeId) {
+  const path = lastBuildPath(baseDir, worktreeId);
+  try {
+    mkdirSync6(dirname3(path), { recursive: true });
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync6(tmp, JSON.stringify(state));
+    renameSync3(tmp, path);
+  } catch {
+  }
+}
+function readLastBuild(baseDir, worktreeId) {
+  let path = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync5(path)) {
+    if (worktreeId === void 0)
+      return null;
+    const legacy = lastBuildPath(baseDir, void 0);
+    if (!existsSync5(legacy))
+      return null;
+    path = legacy;
+  }
+  let raw;
+  try {
+    raw = readFileSync8(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 existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname4, join as join10 } from "node:path";
+function historyPath(baseDir) {
+  return join10(baseDir, "history.jsonl");
+}
+function appendHistoryEntry(baseDir, entry) {
+  const path = historyPath(baseDir);
+  try {
+    mkdirSync7(dirname4(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
+  };
+}
+
+// dist/src/graph/snapshot.js
+import { createHash as createHash4 } from "node:crypto";
+import { mkdirSync as mkdirSync8, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname5, join as join11 } from "node:path";
+
+// dist/src/graph/resolve/cross-file.js
+import { posix } from "node:path";
+var EXPORTABLE_KINDS = /* @__PURE__ */ new Set([
+  "function",
+  "class",
+  "const",
+  "interface",
+  "type_alias",
+  "enum"
+]);
+var HERITAGE_KINDS = /* @__PURE__ */ new Set([
+  "class",
+  "interface",
+  "type_alias",
+  "enum"
+]);
+function buildExportIndex(nodes) {
+  const idx = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (!n.exported || !EXPORTABLE_KINDS.has(n.kind))
+      continue;
+    let m = idx.get(n.source_file);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      idx.set(n.source_file, m);
+    }
+    if (!m.has(n.label))
+      m.set(n.label, n.id);
+  }
+  return idx;
+}
+function resolveCrossFileCalls(extractions, nodes) {
+  const knownFiles = /* @__PURE__ */ new Set();
+  for (const ex of extractions)
+    knownFiles.add(ex.source_file);
+  const exportIndex = buildExportIndex(nodes);
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ex of extractions) {
+    const rawCalls = ex.raw_calls ?? [];
+    const bindings = ex.import_bindings ?? [];
+    if (rawCalls.length === 0 || bindings.length === 0)
+      continue;
+    const byLocal = /* @__PURE__ */ new Map();
+    for (const b of bindings) {
+      if (!byLocal.has(b.local_name))
+        byLocal.set(b.local_name, b);
+    }
+    for (const rc of rawCalls) {
+      const target = resolveOne(rc, byLocal, ex.source_file, knownFiles, exportIndex);
+      if (target === null)
+        continue;
+      const key = `${rc.caller_id}\0${target}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      edges.push({
+        source: rc.caller_id,
+        target,
+        relation: "calls",
+        confidence: "EXTRACTED"
+      });
+    }
+  }
+  return edges;
+}
+function resolveOne(rc, byLocal, fromFile, knownFiles, exportIndex) {
+  let binding;
+  let exportName;
+  if (rc.receiver !== void 0) {
+    binding = byLocal.get(rc.receiver);
+    if (binding === void 0 || binding.kind !== "namespace")
+      return null;
+    if (binding.type_only)
+      return null;
+    exportName = rc.callee_name;
+  } else {
+    binding = byLocal.get(rc.callee_name);
+    if (binding === void 0)
+      return null;
+    if (binding.type_only)
+      return null;
+    if (binding.kind !== "named")
+      return null;
+    exportName = binding.imported_name;
+  }
+  const targetFile = resolveModule(fromFile, binding.specifier, knownFiles);
+  if (targetFile === null)
+    return null;
+  return exportIndex.get(targetFile)?.get(exportName) ?? null;
+}
+var MODULE_SUFFIX = "::module";
+var EXTERNAL_PREFIX = "external:";
+function repointImportEdges(links, knownFiles) {
+  return links.map((e) => {
+    if (e.relation !== "imports" || !e.target.startsWith(EXTERNAL_PREFIX))
+      return e;
+    if (!e.source.endsWith(MODULE_SUFFIX))
+      return e;
+    const fromFile = e.source.slice(0, -MODULE_SUFFIX.length);
+    const specifier = e.target.slice(EXTERNAL_PREFIX.length);
+    const resolved = resolveModule(fromFile, specifier, knownFiles);
+    if (resolved === null)
+      return e;
+    return { ...e, target: `${resolved}${MODULE_SUFFIX}` };
+  });
+}
+var UNRESOLVED_PREFIX = "unresolved:";
+function resolveHeritageEdges(links, extractions, nodes) {
+  const knownFiles = /* @__PURE__ */ new Set();
+  for (const ex of extractions)
+    knownFiles.add(ex.source_file);
+  const exportIndex = buildExportIndex(nodes);
+  const localIndex = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (!HERITAGE_KINDS.has(n.kind))
+      continue;
+    let m = localIndex.get(n.source_file);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      localIndex.set(n.source_file, m);
+    }
+    if (!m.has(n.label))
+      m.set(n.label, n.id);
+  }
+  const bindingsByFile = /* @__PURE__ */ new Map();
+  for (const ex of extractions) {
+    const m = /* @__PURE__ */ new Map();
+    for (const b of ex.import_bindings ?? [])
+      if (!m.has(b.local_name))
+        m.set(b.local_name, b);
+    bindingsByFile.set(ex.source_file, m);
+  }
+  return links.map((e) => {
+    if (e.relation !== "extends" && e.relation !== "implements")
+      return e;
+    if (!e.target.startsWith(UNRESOLVED_PREFIX))
+      return e;
+    const parsed = parseUnresolved(e.target);
+    if (parsed === null)
+      return e;
+    const { file, name } = parsed;
+    const local = localIndex.get(file)?.get(name);
+    if (local !== void 0)
+      return { ...e, target: local };
+    const binding = bindingsByFile.get(file)?.get(name);
+    if (binding !== void 0 && binding.kind === "named") {
+      const targetFile = resolveModule(file, binding.specifier, knownFiles);
+      if (targetFile !== null) {
+        const id = exportIndex.get(targetFile)?.get(binding.imported_name);
+        if (id !== void 0)
+          return { ...e, target: id };
+      }
+    }
+    return e;
+  });
+}
+function parseUnresolved(target) {
+  const body = target.slice(UNRESOLVED_PREFIX.length);
+  const lastColon = body.lastIndexOf(":");
+  if (lastColon <= 0)
+    return null;
+  const rest = body.slice(0, lastColon);
+  const nameColon = rest.lastIndexOf(":");
+  if (nameColon <= 0)
+    return null;
+  const file = rest.slice(0, nameColon);
+  const name = rest.slice(nameColon + 1);
+  if (file.length === 0 || name.length === 0)
+    return null;
+  return { file, name };
+}
+function resolveModule(fromFile, specifier, knownFiles) {
+  if (isPythonFile(fromFile))
+    return resolvePythonModule(fromFile, specifier, knownFiles);
+  if (!specifier.startsWith("./") && !specifier.startsWith("../"))
+    return null;
+  const baseDir = posix.dirname(fromFile);
+  const explicit = specifier.match(/\.(tsx?|jsx?|mjs|cjs)$/)?.[0] ?? null;
+  const stem = explicit ? specifier.slice(0, -explicit.length) : specifier;
+  const joined = posix.normalize(posix.join(baseDir, stem));
+  const TS_EXTS = [".ts", ".tsx"];
+  const JS_EXTS = [".js", ".jsx", ".mjs", ".cjs"];
+  const importerIsJs = /\.(jsx?|mjs|cjs)$/.test(fromFile);
+  const primary = importerIsJs ? JS_EXTS : TS_EXTS;
+  const secondary = importerIsJs ? TS_EXTS : JS_EXTS;
+  const exts = [
+    ...explicit ? [explicit] : [],
+    ...primary,
+    ...secondary
+  ].filter((e, i, a) => a.indexOf(e) === i);
+  for (const e of exts) {
+    const c = `${joined}${e}`;
+    if (knownFiles.has(c))
+      return c;
+  }
+  for (const e of exts) {
+    const c = `${joined}/index${e}`;
+    if (knownFiles.has(c))
+      return c;
+  }
+  return null;
+}
+var PY_EXTS = [".py", ".pyi"];
+function isPythonFile(p) {
+  return p.endsWith(".py") || p.endsWith(".pyi");
+}
+function resolvePythonModule(fromFile, specifier, knownFiles) {
+  let dots = 0;
+  while (dots < specifier.length && specifier[dots] === ".")
+    dots++;
+  const tail = specifier.slice(dots);
+  const segs = tail.length > 0 ? tail.split(".") : [];
+  if (dots === 0) {
+    if (segs.length === 0)
+      return null;
+    return matchPythonSuffix(segs.join("/"), knownFiles);
+  }
+  let dir = posix.dirname(fromFile);
+  let climbed = 1;
+  for (; climbed < dots && dir !== "" && dir !== "."; climbed++)
+    dir = posix.dirname(dir);
+  if (climbed < dots)
+    return null;
+  const base = segs.length > 0 ? posix.normalize(posix.join(dir, ...segs)) : dir;
+  for (const e of PY_EXTS)
+    if (knownFiles.has(`${base}${e}`))
+      return `${base}${e}`;
+  for (const e of PY_EXTS)
+    if (knownFiles.has(`${base}/__init__${e}`))
+      return `${base}/__init__${e}`;
+  return null;
+}
+function matchPythonSuffix(suffix, knownFiles) {
+  const targets = [
+    ...PY_EXTS.map((e) => `${suffix}${e}`),
+    ...PY_EXTS.map((e) => `${suffix}/__init__${e}`)
+  ];
+  for (const t of targets) {
+    if (knownFiles.has(t))
+      return t;
+    let hit = null;
+    let count = 0;
+    for (const f of knownFiles) {
+      if (f.endsWith(`/${t}`)) {
+        hit = f;
+        count++;
+      }
+    }
+    if (count === 1)
+      return hit;
+    if (count > 1)
+      return null;
+  }
+  return null;
+}
+
+// dist/src/graph/node-metadata.js
+function annotateNodeDegrees(nodes, links) {
+  const inDeg = /* @__PURE__ */ new Map();
+  const outDeg = /* @__PURE__ */ new Map();
+  for (const e of links) {
+    outDeg.set(e.source, (outDeg.get(e.source) ?? 0) + 1);
+    inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+  }
+  for (const n of nodes) {
+    const fi = inDeg.get(n.id) ?? 0;
+    const fo = outDeg.get(n.id) ?? 0;
+    n.fan_in = fi;
+    n.fan_out = fo;
+    n.is_entrypoint = n.exported && fi === 0;
+  }
+}
+
+// dist/src/graph/snapshot.js
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join11(homedir6(), ".hivemind", "graphs");
+}
+function repoDir(repoKey) {
+  return join11(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);
+  }
+  for (const e of resolveCrossFileCalls(extractions, nodes))
+    links.push(e);
+  const knownFiles = /* @__PURE__ */ new Set();
+  for (const ex of extractions)
+    knownFiles.add(ex.source_file);
+  let resolvedLinks = repointImportEdges(links, knownFiles);
+  resolvedLinks = resolveHeritageEdges(resolvedLinks, extractions, nodes);
+  annotateNodeDegrees(nodes, resolvedLinks);
+  nodes.sort(compareNodes);
+  resolvedLinks.sort(compareEdges);
+  return {
+    directed: true,
+    multigraph: true,
+    graph: metadata,
+    observation,
+    nodes,
+    links: resolvedLinks
+  };
+}
+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 = join11(baseDir, "snapshots");
+  const snapshotPath = join11(snapshotsDir, `${fileBase}.json`);
+  const canonical = canonicalSnapshot(snapshot);
+  writeFileAtomic(snapshotPath, canonical);
+  const worktreeRoot = worktreeId !== void 0 ? join11(baseDir, "worktrees", worktreeId) : baseDir;
+  let latestCommitPath = null;
+  if (commitSha !== null) {
+    latestCommitPath = join11(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) {
+  mkdirSync8(dirname5(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync7(tmp, contents);
+  renameSync4(tmp, filePath);
+}
+
+// dist/src/graph/diff.js
+import { existsSync as existsSync8, readFileSync as readFileSync10 } from "node:fs";
+import { join as join13 } from "node:path";
+
+// 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_BYTES2 = 16384;
+  const tree = parser.parse((index) => {
+    if (index >= sourceCode.length)
+      return null;
+    return sourceCode.slice(index, index + CHUNK_BYTES2);
+  });
+  const root = tree.rootNode;
+  const result = {
+    source_file: relativePath,
+    language: "typescript",
+    nodes: [],
+    edges: [],
+    parse_errors: [],
+    raw_calls: [],
+    import_bindings: []
+  };
+  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);
+  if (isJavaScriptPath(relativePath)) {
+    result.language = "javascript";
+    for (const n of result.nodes)
+      n.language = "javascript";
+  }
+  return result;
+}
+function isJavaScriptPath(relativePath) {
+  return /\.(jsx?|mjs|cjs)$/.test(relativePath);
+}
+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 isPublic2 = !isHardPrivate && (accessibility === null || accessibility.text === "public");
+            const methodExported = exported && isPublic2;
+            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"
+        });
+        extractImportBindings(node, specifier, result);
+      }
+    }
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null)
+      extractImports(child, relativePath, result, moduleNode);
+  }
+}
+function extractImportBindings(importStmt, specifier, result) {
+  const stmtTypeOnly = /^import\s+type\b/.test(importStmt.text.trimStart());
+  const clause = firstNamedChildOfTypes(importStmt, ["import_clause"]);
+  if (clause === null)
+    return;
+  const push = (b) => {
+    result.import_bindings.push({ ...b, specifier });
+  };
+  for (let i = 0; i < clause.namedChildCount; i++) {
+    const child = clause.namedChild(i);
+    if (child === null)
+      continue;
+    if (child.type === "identifier") {
+      push({ local_name: child.text, imported_name: "default", kind: "default", type_only: stmtTypeOnly });
+    } else if (child.type === "namespace_import") {
+      const id = firstNamedChildOfTypes(child, ["identifier"]);
+      if (id !== null)
+        push({ local_name: id.text, imported_name: "*", kind: "namespace", type_only: stmtTypeOnly });
+    } else if (child.type === "named_imports") {
+      for (let j = 0; j < child.namedChildCount; j++) {
+        const spec = child.namedChild(j);
+        if (spec === null || spec.type !== "import_specifier")
+          continue;
+        const specTypeOnly = stmtTypeOnly || /^type\s+(?!as\b)/.test(spec.text);
+        const nameNode = spec.childForFieldName("name");
+        const aliasNode = spec.childForFieldName("alias");
+        const imported = nameNode !== null ? nameNode.text : null;
+        if (imported === null)
+          continue;
+        const local = aliasNode !== null ? aliasNode.text : imported;
+        push({ local_name: local, imported_name: imported, kind: "named", type_only: specTypeOnly });
+      }
+    }
+  }
+}
+function extractCalls(node, relativePath, result, declByName) {
+  if (node.type === "call_expression") {
+    const callee = node.childForFieldName("function");
+    if (callee !== null) {
+      const callerNode = findEnclosingDeclaration(node, declByName);
+      if (callerNode !== null) {
+        const calleeKey = resolveCalleeKey(callee, declByName);
+        const targetNode = calleeKey !== null ? declByName.get(calleeKey) : void 0;
+        if (targetNode !== void 0) {
+          result.edges.push({
+            source: callerNode.id,
+            target: targetNode.id,
+            relation: "calls",
+            confidence: "EXTRACTED"
+          });
+        } else {
+          const rc = rawCallFromCallee(callee, callerNode.id);
+          if (rc !== null)
+            result.raw_calls.push(rc);
+        }
+      }
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child !== null)
+      extractCalls(child, relativePath, result, declByName);
+  }
+}
+function rawCallFromCallee(callee, callerId) {
+  if (callee.type === "identifier") {
+    return { caller_id: callerId, callee_name: callee.text };
+  }
+  if (callee.type === "member_expression") {
+    const object = callee.childForFieldName("object");
+    const property = callee.childForFieldName("property");
+    if (object !== null && object.type === "identifier" && property !== null && property.type === "property_identifier") {
+      return { caller_id: callerId, callee_name: property.text, receiver: object.text };
+    }
+  }
+  return null;
+}
+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,
+    signature: signatureOf(node, kind)
+  };
+}
+function signatureOf(node, kind) {
+  const text = node.text;
+  let end = text.length;
+  const nl = text.indexOf("\n");
+  if (nl >= 0)
+    end = Math.min(end, nl);
+  const cutsAtBody = kind === "function" || kind === "class" || kind === "method" || kind === "interface" || kind === "enum";
+  if (cutsAtBody) {
+    const body = node.childForFieldName("body");
+    if (body !== null) {
+      end = Math.min(end, body.startIndex - node.startIndex);
+    } else {
+      const brace = text.indexOf("{");
+      if (brace >= 0)
+        end = Math.min(end, brace);
+    }
+  }
+  const sig = text.slice(0, end).replace(/\s+/g, " ").trim();
+  const cps = [...sig];
+  return cps.length > 120 ? `${cps.slice(0, 117).join("")}...` : sig;
+}
+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,
+    signature: signatureOf(node, kind)
+  };
+}
+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/extract/python.js
+import Parser2 from "tree-sitter";
+import Python from "tree-sitter-python";
+var _pythonParser = null;
+function getPythonParser() {
+  if (_pythonParser === null) {
+    _pythonParser = new Parser2();
+    _pythonParser.setLanguage(Python);
+  }
+  return _pythonParser;
+}
+var CHUNK_BYTES = 16384;
+function extractPython(sourceCode, relativePath) {
+  const parser = getPythonParser();
+  const tree = parser.parse((index) => index >= sourceCode.length ? null : sourceCode.slice(index, index + CHUNK_BYTES));
+  const root = tree.rootNode;
+  const result = {
+    source_file: relativePath,
+    language: "python",
+    nodes: [],
+    edges: [],
+    parse_errors: [],
+    raw_calls: [],
+    import_bindings: []
+  };
+  collectParseErrors2(root, relativePath, result.parse_errors);
+  const moduleNode = makeModuleNode2(relativePath);
+  result.nodes.push(moduleNode);
+  const declByName = /* @__PURE__ */ new Map();
+  extractDeclarations2(
+    root,
+    relativePath,
+    result,
+    declByName,
+    /*topLevel*/
+    true
+  );
+  extractImports2(root, relativePath, result, moduleNode);
+  extractCalls2(root, result, declByName);
+  return result;
+}
+function collectParseErrors2(node, relativePath, out) {
+  if (node.isError || node.isMissing) {
+    out.push({ source_file: relativePath, message: node.isMissing ? `missing node: ${node.type}` : `parse error at ${loc(node)}`, location: loc(node) });
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c !== null)
+      collectParseErrors2(c, relativePath, out);
+  }
+}
+function extractDeclarations2(node, relativePath, result, declByName, topLevel) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    if (child === null)
+      continue;
+    if (child.type === "function_definition") {
+      const name = textOfField2(child, "name");
+      if (name !== null)
+        pushNode2(result, declByName, makeNode2(relativePath, name, "function", child, isPublic(name)));
+    } else if (child.type === "class_definition") {
+      handleClass(child, relativePath, result, declByName);
+    } else if (topLevel && child.type === "expression_statement") {
+      const assign = firstOfType(child, "assignment");
+      if (assign !== null) {
+        const lhs = assign.childForFieldName("left");
+        if (lhs !== null && lhs.type === "identifier") {
+          pushNode2(result, declByName, makeNode2(relativePath, lhs.text, "const", assign, isPublic(lhs.text)));
+        }
+      }
+    } else if (child.type === "decorated_definition") {
+      extractDeclarations2(child, relativePath, result, declByName, topLevel);
+    }
+  }
+}
+function handleClass(node, relativePath, result, declByName) {
+  const name = textOfField2(node, "name");
+  if (name === null)
+    return;
+  const classNode = makeNode2(relativePath, name, "class", node, isPublic(name));
+  pushNode2(result, declByName, classNode);
+  const supers = node.childForFieldName("superclasses");
+  if (supers !== null) {
+    for (let i = 0; i < supers.namedChildCount; i++) {
+      const base = supers.namedChild(i);
+      if (base === null)
+        continue;
+      let baseName = null;
+      if (base.type === "identifier")
+        baseName = base.text;
+      else if (base.type === "attribute") {
+        const attr = base.childForFieldName("attribute");
+        baseName = attr !== null ? attr.text : null;
+      }
+      if (baseName === null || baseName.length === 0)
+        continue;
+      result.edges.push({
+        source: classNode.id,
+        target: nodeIdUnresolved2(relativePath, baseName, "class"),
+        relation: "extends",
+        confidence: "EXTRACTED"
+      });
+    }
+  }
+  const body = node.childForFieldName("body");
+  if (body !== null) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+      let member = body.namedChild(i);
+      if (member === null)
+        continue;
+      if (member.type === "decorated_definition")
+        member = firstOfType(member, "function_definition");
+      if (member === null || member.type !== "function_definition")
+        continue;
+      const mName = textOfField2(member, "name");
+      if (mName === null)
+        continue;
+      const methodNode = makeNodeWithExplicitLabel2(relativePath, `${name}.${mName}`, mName, "method", member, isPublic(name) && isPublic(mName));
+      pushNode2(result, declByName, methodNode);
+      result.edges.push({ source: classNode.id, target: methodNode.id, relation: "method_of", confidence: "EXTRACTED" });
+    }
+  }
+}
+function extractImports2(node, relativePath, result, moduleNode) {
+  if (node.type === "import_statement") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child === null)
+        continue;
+      let modText = null;
+      let local = null;
+      if (child.type === "dotted_name") {
+        modText = child.text;
+        local = lastDottedSegment(child.text);
+      } else if (child.type === "aliased_import") {
+        const name = child.childForFieldName("name");
+        const alias = child.childForFieldName("alias");
+        if (name !== null) {
+          modText = name.text;
+          local = alias !== null ? alias.text : lastDottedSegment(name.text);
+        }
+      }
+      if (modText !== null) {
+        pushImportEdge(result, moduleNode, modText);
+        if (local !== null)
+          result.import_bindings.push({ local_name: local, imported_name: "*", kind: "namespace", specifier: modText });
+      }
+    }
+    return;
+  }
+  if (node.type === "import_from_statement") {
+    const modNode = node.childForFieldName("module_name");
+    const modText = modNode !== null ? modNode.text : ".";
+    pushImportEdge(result, moduleNode, modText);
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child === null || child === modNode)
+        continue;
+      if (child.type === "dotted_name" || child.type === "identifier") {
+        const imported = child.text;
+        result.import_bindings.push({ local_name: lastDottedSegment(imported), imported_name: imported, kind: "named", specifier: modText });
+      } else if (child.type === "aliased_import") {
+        const name = child.childForFieldName("name");
+        const alias = child.childForFieldName("alias");
+        if (name !== null)
+          result.import_bindings.push({ local_name: alias !== null ? alias.text : lastDottedSegment(name.text), imported_name: name.text, kind: "named", specifier: modText });
+      }
+    }
+    return;
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c !== null)
+      extractImports2(c, relativePath, result, moduleNode);
+  }
+}
+function pushImportEdge(result, moduleNode, specifier) {
+  if (specifier.length === 0)
+    return;
+  result.edges.push({ source: moduleNode.id, target: `external:${specifier}`, relation: "imports", confidence: "EXTRACTED" });
+}
+function extractCalls2(node, result, declByName) {
+  if (node.type === "call") {
+    const callee = node.childForFieldName("function");
+    if (callee !== null) {
+      const caller = findEnclosingDeclaration2(node, declByName);
+      if (caller !== null) {
+        const key = resolveCalleeKey2(callee);
+        const target = key !== null ? declByName.get(key) : void 0;
+        if (target !== void 0) {
+          result.edges.push({ source: caller.id, target: target.id, relation: "calls", confidence: "EXTRACTED" });
+        } else {
+          const rc = rawCallFromCallee2(callee, caller.id);
+          if (rc !== null)
+            result.raw_calls.push(rc);
+        }
+      }
+    }
+  }
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c !== null)
+      extractCalls2(c, result, declByName);
+  }
+}
+function resolveCalleeKey2(callee) {
+  if (callee.type === "identifier")
+    return callee.text;
+  if (callee.type === "attribute") {
+    const obj = callee.childForFieldName("object");
+    const attr = callee.childForFieldName("attribute");
+    if (obj !== null && obj.type === "identifier" && obj.text === "self" && attr !== null) {
+      const cls = findEnclosingClassName2(callee);
+      if (cls !== null)
+        return `${cls}.${attr.text}`;
+    }
+  }
+  return null;
+}
+function rawCallFromCallee2(callee, callerId) {
+  if (callee.type === "identifier")
+    return { caller_id: callerId, callee_name: callee.text };
+  if (callee.type === "attribute") {
+    const obj = callee.childForFieldName("object");
+    const attr = callee.childForFieldName("attribute");
+    if (obj !== null && obj.type === "identifier" && obj.text !== "self" && attr !== null) {
+      return { caller_id: callerId, callee_name: attr.text, receiver: obj.text };
+    }
+  }
+  return null;
+}
+function findEnclosingDeclaration2(node, declByName) {
+  let cur = node.parent;
+  while (cur !== null) {
+    if (cur.type === "function_definition") {
+      const name = textOfField2(cur, "name");
+      const cls = findEnclosingClassName2(cur);
+      if (name !== null) {
+        const n = cls !== null ? declByName.get(`${cls}.${name}`) : declByName.get(name);
+        if (n !== void 0)
+          return n;
+      }
+    }
+    cur = cur.parent;
+  }
+  return null;
+}
+function findEnclosingClassName2(node) {
+  let cur = node.parent;
+  while (cur !== null) {
+    if (cur.type === "class_definition")
+      return textOfField2(cur, "name");
+    cur = cur.parent;
+  }
+  return null;
+}
+function makeNode2(relativePath, name, kind, node, exported) {
+  return { id: nodeId2(relativePath, name, kind), label: name, kind, source_file: relativePath, source_location: loc(node), language: "python", exported, signature: signatureOf2(node, kind) };
+}
+function makeNodeWithExplicitLabel2(relativePath, idName, label, kind, node, exported) {
+  return { id: nodeId2(relativePath, idName, kind), label, kind, source_file: relativePath, source_location: loc(node), language: "python", exported, signature: signatureOf2(node, kind) };
+}
+function makeModuleNode2(relativePath) {
+  return { id: `${relativePath}::module`, label: relativePath, kind: "module", source_file: relativePath, source_location: "L1", language: "python", exported: false };
+}
+function pushNode2(result, declByName, node) {
+  result.nodes.push(node);
+  const key = node.kind === "method" ? node.id.split(":")[1] : node.label;
+  if (!declByName.has(key))
+    declByName.set(key, node);
+}
+function signatureOf2(node, kind) {
+  const text = node.text;
+  let end = text.length;
+  const nl = text.indexOf("\n");
+  if (nl >= 0)
+    end = Math.min(end, nl);
+  if (kind === "function" || kind === "method" || kind === "class") {
+    const body = node.childForFieldName("body");
+    if (body !== null)
+      end = Math.min(end, body.startIndex - node.startIndex);
+  }
+  const sig = text.slice(0, end).replace(/\s+/g, " ").replace(/:\s*$/, "").trim();
+  const cps = [...sig];
+  return cps.length > 120 ? `${cps.slice(0, 117).join("")}...` : sig;
+}
+function nodeId2(relativePath, name, kind) {
+  return `${relativePath}:${name}:${kind}`;
+}
+function nodeIdUnresolved2(relativePath, name, kind) {
+  return `unresolved:${relativePath}:${name}:${kind}`;
+}
+function loc(node) {
+  const start = node.startPosition.row + 1;
+  const end = node.endPosition.row + 1;
+  return end > start ? `L${start}-${end}` : `L${start}`;
+}
+function textOfField2(node, field) {
+  const f = node.childForFieldName(field);
+  return f !== null ? f.text : null;
+}
+function firstOfType(node, type) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c !== null && c.type === type)
+      return c;
+  }
+  return null;
+}
+function lastDottedSegment(dotted) {
+  const parts = dotted.split(".");
+  return parts[parts.length - 1] ?? dotted;
+}
+function isPublic(name) {
+  return !name.startsWith("_");
+}
+
+// dist/src/graph/extract/index.js
+function isPythonPath(relativePath) {
+  return /\.pyi?$/.test(relativePath);
+}
+function extractFile(sourceCode, relativePath) {
+  if (isPythonPath(relativePath))
+    return extractPython(sourceCode, relativePath);
+  return extractTypeScript(sourceCode, relativePath);
+}
+
+// dist/src/graph/ignore-config.js
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join14 } from "node:path";
+var DEFAULT_IGNORE_DIRS = [
+  // JS / TS toolchains
+  "node_modules",
+  "bower_components",
+  "jspm_packages",
+  ".pnpm-store",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  "bundle",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".parcel-cache",
+  ".cache",
+  ".vite",
+  ".nyc_output",
+  // Python
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "virtualenv",
+  "__pycache__",
+  "site-packages",
+  "__pypackages__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".tox",
+  ".eggs",
+  ".ipynb_checkpoints",
+  ".hypothesis",
+  // Rust / Java / .NET / Go vendoring
+  "target",
+  "obj",
+  "vendor",
+  ".gradle",
+  ".mvn",
+  // Native / mobile
+  "Pods",
+  "DerivedData",
+  ".build",
+  // VCS / IDE
+  ".git",
+  ".svn",
+  ".hg",
+  ".idea",
+  ".vscode",
+  ".vs",
+  // Infra / misc
+  ".terraform",
+  "tmp",
+  "temp",
+  "logs",
+  "third_party",
+  "third-party"
+];
+var FILE_NAME = "graph-ignore.json";
+function defaultConfigObject() {
+  return {
+    _comment: "Directory names skipped when building the hivemind code graph. Edit freely. When respectGitignore is true, the repo's .gitignore is also honored (anchoring-correct).",
+    ignoreDirs: [...DEFAULT_IGNORE_DIRS],
+    respectGitignore: true
+  };
+}
+function loadGraphIgnore(deeplakeDir = join14(homedir7(), ".deeplake")) {
+  const path = join14(deeplakeDir, FILE_NAME);
+  try {
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const ignoreDirs = Array.isArray(parsed.ignoreDirs) ? parsed.ignoreDirs.filter((s) => typeof s === "string") : [...DEFAULT_IGNORE_DIRS];
+    const respectGitignore = typeof parsed.respectGitignore === "boolean" ? parsed.respectGitignore : true;
+    return { ignoreDirs, respectGitignore };
+  } catch {
+  }
+  try {
+    mkdirSync10(deeplakeDir, { recursive: true });
+    writeFileSync9(path, JSON.stringify(defaultConfigObject(), null, 2) + "\n", { flag: "wx" });
+  } catch {
+  }
+  return { ignoreDirs: [...DEFAULT_IGNORE_DIRS], respectGitignore: true };
+}
+function ignoreDirSet(config) {
+  return new Set(config.ignoreDirs);
+}
+function pathHasIgnoredSegment(relPath, ignore) {
+  const segs = relPath.split("/");
+  return segs.some((seg, i) => ignore.has(seg) || i < segs.length - 1 && seg.startsWith("."));
+}
+
+// dist/src/graph/git-hook-install.js
+import { chmodSync, existsSync as existsSync9, mkdirSync as mkdirSync11, readFileSync as readFileSync12, unlinkSync as unlinkSync4, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname7, join as join15, resolve as resolve3 } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+
+// dist/src/commands/graph.js
+var USAGE = `hivemind graph \u2014 codebase-graph commands (TypeScript / JavaScript / Python)
+
+Usage:
+  hivemind graph build [--cwd <path>]
+      Walk the project for supported source files (TS/JS/Python), 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.
+`;
+function parseBuildArgs(args) {
+  let cwd = process.cwd();
+  let trigger = "manual";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--cwd" && i + 1 < args.length) {
+      cwd = args[i + 1];
+      i += 1;
+    } else if (a === "--trigger" && i + 1 < args.length) {
+      const v = args[i + 1];
+      if (v === "manual" || v === "session-end" || v === "post-commit" || v === "unknown") {
+        trigger = v;
+      } else {
+        console.error(`hivemind graph build: --trigger must be one of manual|session-end|post-commit|unknown (got '${v}')`);
+        process.exit(2);
+      }
+      i += 1;
+    } else if (a === "--help" || a === "-h") {
+      console.log(USAGE);
+      process.exit(0);
+    } else {
+      console.error(`hivemind graph build: unknown argument '${a}'`);
+      console.error(USAGE);
+      process.exit(2);
+    }
+  }
+  return { cwd, trigger };
+}
+async function runBuildCommand(args) {
+  const opts = parseBuildArgs(args);
+  const cwd = resolve4(opts.cwd);
+  const { key: repoKey, project } = deriveProjectKey(cwd);
+  const baseDir = repoDir(repoKey);
+  const commitSha = readGitCommit(cwd);
+  const branch = readGitBranch(cwd);
+  const version = getVersion();
+  console.log(`Building codebase graph for ${project}`);
+  console.log(`  repo_key:   ${repoKey}`);
+  console.log(`  commit_sha: ${commitSha ?? "(not in a git repo)"}`);
+  console.log(`  branch:     ${branch ?? "(none / detached)"}`);
+  console.log(`  output:     ${baseDir}`);
+  console.log("");
+  const ignoreConfig = loadGraphIgnore();
+  const sourceFiles = discoverSourceFiles(cwd, ignoreConfig);
+  console.log(`Discovered ${sourceFiles.length} 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 = readFileSync13(abs, "utf8");
+      const contentSha = fileContentHash(content);
+      let extraction = readCache(baseDir, contentSha, rel);
+      if (extraction === null) {
+        extraction = extractFile(content, rel);
+        writeCache(baseDir, contentSha, extraction);
+      } else {
+        cacheHits += 1;
+      }
+      if (extraction.parse_errors.length > 0) {
+        totalParseErrors += extraction.parse_errors.length;
+        for (const err of extraction.parse_errors) {
+          console.warn(`  warn: parse issue in ${err.source_file} ${err.location ?? ""}: ${err.message}`);
+        }
+      }
+      extractions.push(extraction);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`  warn: skipping ${rel}: ${msg}`);
+      skipped += 1;
+    }
+  }
+  const metadata = {
+    schema_version: 1,
+    generator: "hivemind-graph",
+    commit_sha: commitSha,
+    repo_key: repoKey
+  };
+  const observation = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    branch,
+    worktree_path: cwd,
+    repo_project: project,
+    generator_version: version,
+    source_files_extracted: extractions.length,
+    source_files_skipped: skipped
+  };
+  const snapshot = buildSnapshot(extractions, metadata, observation);
+  const worktreeId = workTreeIdFor(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 workTreeIdFor(cwd) {
+  return createHash6("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function discoverSourceFiles(rootDir, config) {
+  const ignore = ignoreDirSet(config);
+  if (config.respectGitignore) {
+    const fromGit = gitListSourceFiles(rootDir, ignore);
+    if (fromGit !== null)
+      return fromGit;
+  }
+  const out = [];
+  walk(rootDir, out, ignore);
+  out.sort();
+  return out;
+}
+function gitListSourceFiles(rootDir, ignore) {
+  let stdout;
+  try {
+    stdout = execSync2("git ls-files --cached --others --exclude-standard -z", {
+      cwd: rootDir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      maxBuffer: 64 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+  const out = [];
+  for (const rel of stdout.split("\0")) {
+    if (rel.length === 0)
+      continue;
+    if (!isSourceFile(rel))
+      continue;
+    if (pathHasIgnoredSegment(rel, ignore))
+      continue;
+    out.push(join16(rootDir, rel));
+  }
+  out.sort();
+  return out;
+}
+function walk(dir, out, ignore) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (ignore.has(entry.name))
+      continue;
+    if (entry.name.startsWith("."))
+      continue;
+    const abs = join16(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(abs, out, ignore);
+    } else if (entry.isFile() && isSourceFile(entry.name)) {
+      out.push(abs);
+    }
+  }
+}
+function isSourceFile(name) {
+  if (name.endsWith(".d.ts"))
+    return false;
+  return /\.(tsx?|jsx?|mjs|cjs|pyi?)$/.test(name);
+}
+function toForwardSlash(p) {
+  return sep === "\\" ? p.replace(/\\/g, "/") : p;
+}
+function readGitCommit(cwd) {
+  try {
+    return execSync2("git rev-parse HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function readGitBranch(cwd) {
+  try {
+    const out = execSync2("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/graph/build-lock.js
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync14, statSync as statSync2, unlinkSync as unlinkSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join17 } from "node:path";
+var STALE_LOCK_MS = 5 * 60 * 1e3;
+function lockPath2(baseDir) {
+  return join17(baseDir, ".build.in-flight");
+}
+function acquireBuildLock(baseDir) {
+  const path = lockPath2(baseDir);
+  try {
+    mkdirSync12(baseDir, { recursive: true });
+  } catch {
+    return { acquired: false, reason: "fs-error" };
+  }
+  try {
+    writeFileSync11(path, JSON.stringify({ pid: process.pid, ts: Date.now() }), { flag: "wx" });
+    return { acquired: true, reason: "acquired" };
+  } catch (err) {
+    const code = err.code;
+    if (code !== "EEXIST") {
+      return { acquired: false, reason: "fs-error" };
+    }
+  }
+  let ageMs;
+  try {
+    const stat = statSync2(path);
+    ageMs = Date.now() - stat.mtime.getTime();
+  } catch {
+    return { acquired: false, reason: "fs-error" };
+  }
+  if (ageMs <= STALE_LOCK_MS) {
+    return { acquired: false, reason: "held-by-other" };
+  }
+  try {
+    unlinkSync5(path);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      return { acquired: false, reason: "fs-error" };
+    }
+  }
+  try {
+    writeFileSync11(path, JSON.stringify({ pid: process.pid, ts: Date.now() }), { flag: "wx" });
+    return { acquired: true, reason: "stale-recovered" };
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") {
+      return { acquired: false, reason: "held-by-other" };
+    }
+    return { acquired: false, reason: "fs-error" };
+  }
+}
+function releaseBuildLock(baseDir) {
+  const path = lockPath2(baseDir);
+  try {
+    const raw = readFileSync14(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.pid !== process.pid)
+      return;
+    unlinkSync5(path);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return;
+  }
+}
+
+// dist/src/utils/direct-run.js
+import { resolve as resolve5 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function isDirectRun(metaUrl) {
+  const entry = process.argv[1];
+  if (!entry)
+    return false;
+  try {
+    return resolve5(fileURLToPath2(metaUrl)) === resolve5(entry);
+  } catch {
+    return false;
+  }
+}
+
+// dist/src/hooks/graph-on-stop.js
+function workTreeIdFor2(cwd) {
+  return createHash7("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function tickIntervalMs() {
+  const raw = process.env.HIVEMIND_GRAPH_TICK_INTERVAL_MS;
+  if (raw === void 0)
+    return 10 * 60 * 1e3;
+  const parsed = parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 10 * 60 * 1e3;
+}
+var SOURCE_GLOBS = ["*.ts", "*.tsx", "*.js", "*.jsx", "*.mjs", "*.cjs", "*.py", "*.pyi", ":(exclude)*.d.ts"];
+function decideGate(ctx) {
+  if (ctx.envDisable)
+    return { fire: false, reason: "disabled (HIVEMIND_GRAPH_ON_STOP=0)" };
+  const { key: repoKey } = deriveProjectKey(ctx.cwd);
+  const baseDir = repoDir(repoKey);
+  const last = readLastBuild(baseDir, workTreeIdFor2(ctx.cwd));
+  const head = readGitCommit2(ctx.cwd);
+  if (head === null) {
+    return { fire: false, reason: "not in a git repo" };
+  }
+  if (last === null) {
+    return { fire: true, reason: "first build (no prior .last-build.json)" };
+  }
+  if (ctx.now - last.ts < ctx.intervalMs) {
+    return { fire: false, reason: `rate limit (${Math.round((ctx.now - last.ts) / 1e3)}s < ${Math.round(ctx.intervalMs / 1e3)}s)` };
+  }
+  if (head === last.commit_sha) {
+    return { fire: false, reason: "HEAD unchanged since last build" };
+  }
+  const changedSourceCount = countSourceDiff(ctx.cwd, last.commit_sha, head);
+  if (changedSourceCount < 1) {
+    return { fire: false, reason: "no source files changed since last build" };
+  }
+  return { fire: true, reason: `${changedSourceCount} source file(s) changed since last build` };
+}
+function countSourceDiff(cwd, from, to) {
+  if (from === null)
+    return 1;
+  try {
+    const out = execFileSync3("git", ["diff", "--name-only", `${from}..${to}`, "--", ...SOURCE_GLOBS], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out === "" ? 0 : out.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+function readGitCommit2(cwd) {
+  try {
+    return execFileSync3("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function main(deps = {}) {
+  const runBuildFn = deps.runBuildCommand ?? runBuildCommand;
+  const acquireFn = deps.acquireBuildLock ?? acquireBuildLock;
+  const releaseFn = deps.releaseBuildLock ?? releaseBuildLock;
+  const gateFn = deps.decideGate ?? decideGate;
+  const envDisable = process.env.HIVEMIND_GRAPH_ON_STOP === "0";
+  const ctx = {
+    cwd: process.cwd(),
+    now: Date.now(),
+    intervalMs: tickIntervalMs(),
+    envDisable
+  };
+  let decision;
+  try {
+    decision = gateFn(ctx);
+  } catch (err) {
+    logToFile(ctx.cwd, `decideGate threw: ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+  logToFile(ctx.cwd, `gate: ${decision.fire ? "FIRE" : "SKIP"} (${decision.reason})`);
+  if (!decision.fire)
+    return;
+  const { key: repoKey } = deriveProjectKey(ctx.cwd);
+  const baseDir = repoDir(repoKey);
+  const lock = acquireFn(baseDir);
+  if (!lock.acquired) {
+    logToFile(ctx.cwd, `build skipped: lock ${lock.reason}`);
+    return;
+  }
+  logToFile(ctx.cwd, `lock: ${lock.reason}`);
+  try {
+    await runBuildFn(["--trigger", "session-end"]);
+  } catch (err) {
+    logToFile(ctx.cwd, `build threw: ${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    releaseFn(baseDir);
+  }
+}
+function logToFile(cwd, line) {
+  try {
+    const { key } = deriveProjectKey(cwd);
+    const dir = repoDir(key);
+    mkdirSync13(dir, { recursive: true });
+    appendFileSync3(join18(dir, ".graph-on-stop.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${line}
+`);
+  } catch {
+  }
+}
+if (isDirectRun(import.meta.url)) {
+  main().catch((err) => {
+    console.error(`graph-on-stop fatal: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(0);
+  });
+}
+export {
+  decideGate,
+  main
+};