@deeplake/hivemind 0.7.75 → 0.7.77

package/bundle/cli.js

@@ -372,16 +372,29 @@ function buildHooksJson() {
       UserPromptSubmit: [hookCmd("capture.js", 10)],
       PreToolUse: [hookCmd("pre-tool-use.js", 10, "Bash")],
       PostToolUse: [hookCmd("capture.js", 15)],
-      Stop: [hookCmd("stop.js", 30)]
+      // One Stop matcher-block with TWO commands — stop.js (capture) +
+      // graph-on-stop.js (code-graph auto-build, G3). Single block (not two)
+      // mirrors the static codex/hooks/hooks.json and keeps one entry per
+      // event for the merge/dedupe logic.
+      Stop: [stopBlockWithGraph(30)]
     }
   };
 }
+function stopBlockWithGraph(timeout) {
+  return {
+    hooks: [
+      { type: "command", command: `node "${join4(PLUGIN_DIR, "bundle", "stop.js")}"`, timeout },
+      { type: "command", command: `node "${join4(PLUGIN_DIR, "bundle", "graph-on-stop.js")}"`, timeout }
+    ]
+  };
+}
 var HIVEMIND_BUNDLE_FILES = [
   "session-start.js",
   "session-start-setup.js",
   "capture.js",
   "pre-tool-use.js",
   "stop.js",
+  "graph-on-stop.js",
   "wiki-worker.js"
 ];
 function isHivemindHookEntry(entry, pluginDir = PLUGIN_DIR) {
@@ -716,8 +729,12 @@ function buildHookConfig() {
     preToolUse: [buildHookCmdShellMatcher("pre-tool-use.js", 30)],
     postToolUse: [buildHookCmd("capture.js", 15)],
     afterAgentResponse: [buildHookCmd("capture.js", 15)],
-    stop: [buildHookCmd("capture.js", 15)],
-    sessionEnd: [buildHookCmd("session-end.js", 30)]
+    // graph-on-stop: auto-build the code graph (A1 Cursor parity). Same hook
+    // Claude Code registers under Stop + SessionEnd. It's gated (rate limit +
+    // HEAD-changed + source-diff) so the common path is a ~5ms skip, and runs
+    // async so it never blocks Cursor.
+    stop: [buildHookCmd("capture.js", 15), buildHookCmd("graph-on-stop.js", 30)],
+    sessionEnd: [buildHookCmd("session-end.js", 30), buildHookCmd("graph-on-stop.js", 30)]
   };
 }
 function isHivemindEntry(entry) {
@@ -3479,7 +3496,10 @@ function buildHooksBlock() {
     pre_llm_call: [buildHookEntry("capture.js", 10)],
     post_tool_call: [buildHookEntry("capture.js", 15)],
     post_llm_call: [buildHookEntry("capture.js", 15)],
-    on_session_end: [buildHookEntry("session-end.js", 30)]
+    // graph-on-stop: code-graph auto-build parity (G3), same gated hook as the
+    // other agents. on_session_end is Hermes's session-close event (analogous
+    // to Claude Code's SessionEnd).
+    on_session_end: [buildHookEntry("session-end.js", 30), buildHookEntry("graph-on-stop.js", 30)]
   };
 }
 function mergeHooks3(existing) {
@@ -5653,8 +5673,8 @@ if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
 
 // dist/src/commands/graph.js
 import { execSync as execSync3 } from "node:child_process";
-import { readFileSync as readFileSync20, readdirSync as readdirSync2 } from "node:fs";
-import { join as join27, relative, resolve as resolve4, sep } from "node:path";
+import { readFileSync as readFileSync21, readdirSync as readdirSync2 } from "node:fs";
+import { join as join28, relative, resolve as resolve4, sep } from "node:path";
 import { createHash as createHash6 } from "node:crypto";
 
 // dist/src/graph/cache.js
@@ -6094,6 +6114,282 @@ import { createHash as createHash4 } from "node:crypto";
 import { mkdirSync as mkdirSync10, renameSync as renameSync6, writeFileSync as writeFileSync14 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { dirname as dirname6, join as join23 } 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 ?? join23(homedir10(), ".hivemind", "graphs");
 }
@@ -6109,15 +6405,23 @@ function buildSnapshot(extractions, metadata, observation) {
     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);
-  links.sort(compareEdges);
+  resolvedLinks.sort(compareEdges);
   return {
     directed: true,
     multigraph: true,
     graph: metadata,
     observation,
     nodes,
-    links
+    links: resolvedLinks
   };
 }
 function compareNodes(a, b) {
@@ -6235,8 +6539,20 @@ async function pullSnapshot(cwd, deps = {}) {
   if (cloudPayload === null) {
     return errorOutcome2("SELECT cloud row", new Error("invalid snapshot_jsonb payload"));
   }
+  let parsedSnapshot;
+  try {
+    parsedSnapshot = JSON.parse(cloudPayload);
+  } catch (err) {
+    return errorOutcome2("parse cloud snapshot", err);
+  }
+  if (parsedSnapshot === null || typeof parsedSnapshot !== "object") {
+    return errorOutcome2("parse cloud snapshot", new Error("snapshot not an object"));
+  }
+  if (!Array.isArray(parsedSnapshot.nodes) || !Array.isArray(parsedSnapshot.links)) {
+    return errorOutcome2("parse cloud snapshot", new Error("snapshot missing nodes/links arrays"));
+  }
   if (cloudSha256 !== "") {
-    const computedSha = createHash5("sha256").update(cloudPayload).digest("hex");
+    const computedSha = computeSnapshotSha2562(parsedSnapshot);
     if (cloudSha256 !== computedSha) {
       return errorOutcome2("SELECT cloud row", new Error(`snapshot_sha256 mismatch (expected ${cloudSha256}, got ${computedSha})`));
     }
@@ -6454,11 +6770,11 @@ function pickParserForPath(relativePath) {
 }
 function extractTypeScript(sourceCode, relativePath) {
   const parser = pickParserForPath(relativePath);
-  const CHUNK_BYTES = 16384;
+  const CHUNK_BYTES2 = 16384;
   const tree = parser.parse((index) => {
     if (index >= sourceCode.length)
       return null;
-    return sourceCode.slice(index, index + CHUNK_BYTES);
+    return sourceCode.slice(index, index + CHUNK_BYTES2);
   });
   const root = tree.rootNode;
   const result = {
@@ -6466,7 +6782,9 @@ function extractTypeScript(sourceCode, relativePath) {
     language: "typescript",
     nodes: [],
     edges: [],
-    parse_errors: []
+    parse_errors: [],
+    raw_calls: [],
+    import_bindings: []
   };
   collectParseErrors(root, relativePath, result.parse_errors);
   const moduleNode = makeModuleNode(relativePath);
@@ -6475,8 +6793,16 @@ function extractTypeScript(sourceCode, relativePath) {
   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({
@@ -6573,8 +6899,8 @@ function handleDeclaration(node, exported, relativePath, result, declByName, mod
               continue;
             const accessibility = firstNamedChildOfTypes(member, ["accessibility_modifier"]);
             const isHardPrivate = firstNamedChildOfTypes(member, ["private_property_identifier"]) !== null;
-            const isPublic = !isHardPrivate && (accessibility === null || accessibility.text === "public");
-            const methodExported = exported && isPublic;
+            const 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);
@@ -6641,6 +6967,7 @@ function extractImports(node, relativePath, result, moduleNode) {
           relation: "imports",
           confidence: "EXTRACTED"
         });
+        extractImportBindings(node, specifier, result);
       }
     }
     return;
@@ -6651,23 +6978,60 @@ function extractImports(node, relativePath, result, moduleNode) {
       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 calleeKey = resolveCalleeKey(callee, declByName);
-      if (calleeKey !== null) {
-        const targetNode = declByName.get(calleeKey);
+      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) {
-          const callerNode = findEnclosingDeclaration(node, declByName);
-          if (callerNode !== null) {
-            result.edges.push({
-              source: callerNode.id,
-              target: targetNode.id,
-              relation: "calls",
-              confidence: "EXTRACTED"
-            });
-          }
+          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);
         }
       }
     }
@@ -6678,6 +7042,19 @@ function extractCalls(node, relativePath, result, declByName) {
       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;
@@ -6754,9 +7131,31 @@ function makeNode(relativePath, name, kind, node, exported) {
     source_file: relativePath,
     source_location: locationStr(node),
     language: "typescript",
-    exported
+    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),
@@ -6765,7 +7164,8 @@ function makeNodeWithExplicitLabel(relativePath, idName, label, kind, node, expo
     source_file: relativePath,
     source_location: locationStr(node),
     language: "typescript",
-    exported
+    exported,
+    signature: signatureOf(node, kind)
   };
 }
 function pushNode(result, declByName, node, lookupKey) {
@@ -6805,9 +7205,433 @@ function firstNamedChildOfTypes(node, types) {
   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, type2) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c !== null && c.type === type2)
+      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 mkdirSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join26 } 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 = join26(homedir11(), ".deeplake")) {
+  const path = join26(deeplakeDir, FILE_NAME);
+  try {
+    const parsed = JSON.parse(readFileSync19(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 {
+    mkdirSync12(deeplakeDir, { recursive: true });
+    writeFileSync16(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 as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname8, join as join26, resolve as resolve3 } from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync20, unlinkSync as unlinkSync8, writeFileSync as writeFileSync17 } from "node:fs";
+import { dirname as dirname8, join as join27, resolve as resolve3 } from "node:path";
 import { execFileSync as execFileSync5 } from "node:child_process";
 var HOOK_BEGIN_MARKER = "# HIVEMIND_GRAPH_HOOK_BEGIN \u2014 managed by `hivemind graph init`";
 var HOOK_END_MARKER = "# HIVEMIND_GRAPH_HOOK_END";
@@ -6870,7 +7694,7 @@ function tryGitTopLevel(cwd) {
 }
 function postCommitHookPath(cwd) {
   const hooksDir = gitHooksDir(cwd);
-  return hooksDir === null ? null : join26(hooksDir, "post-commit");
+  return hooksDir === null ? null : join27(hooksDir, "post-commit");
 }
 function installPostCommitHook(cwd, opts = {}) {
   const path = postCommitHookPath(cwd);
@@ -6879,7 +7703,7 @@ function installPostCommitHook(cwd, opts = {}) {
   }
   const existed = existsSync20(path);
   if (existed) {
-    const content = readFileSync19(path, "utf8");
+    const content = readFileSync20(path, "utf8");
     if (containsOurMarkers(content)) {
       return { kind: "already-ours", path };
     }
@@ -6899,8 +7723,8 @@ function installPostCommitHook(cwd, opts = {}) {
       hint: "hivemind binary not found on PATH. Install hivemind globally (`npm install -g @deeplake/hivemind`) before running `hivemind graph init`, so the hook can find a stable absolute path to call."
     };
   }
-  mkdirSync12(dirname8(path), { recursive: true });
-  writeFileSync16(path, buildHookFile(hivemindPath), { mode: 493 });
+  mkdirSync13(dirname8(path), { recursive: true });
+  writeFileSync17(path, buildHookFile(hivemindPath), { mode: 493 });
   try {
     chmodSync2(path, 493);
   } catch {
@@ -6927,7 +7751,7 @@ function uninstallPostCommitHook(cwd) {
   if (!existsSync20(path)) {
     return { kind: "no-hook", path };
   }
-  const content = readFileSync19(path, "utf8");
+  const content = readFileSync20(path, "utf8");
   if (!containsOurMarkers(content)) {
     return {
       kind: "not-ours",
@@ -6941,7 +7765,7 @@ function uninstallPostCommitHook(cwd) {
     unlinkSync8(path);
     return { kind: "removed", path, wholeFileDeleted: true };
   }
-  writeFileSync16(path, stripped);
+  writeFileSync17(path, stripped);
   return { kind: "removed", path, wholeFileDeleted: false };
 }
 function containsOurMarkers(content) {
@@ -6967,11 +7791,11 @@ function buildHookFile(hivemindPath) {
 }
 
 // dist/src/commands/graph.js
-var USAGE = `hivemind graph \u2014 codebase-graph commands (Phase 1 \u2014 TypeScript only)
+var USAGE = `hivemind graph \u2014 codebase-graph commands (TypeScript / JavaScript / Python)
 
 Usage:
   hivemind graph build [--cwd <path>]
-      Walk the project for TypeScript source files, extract symbols + edges,
+      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).
@@ -7015,15 +7839,6 @@ Usage:
 
   Future subcommands (Phase 1.5+): daemon, search, latest, push, pull, prune.
 `;
-var DEFAULT_IGNORES = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "bundle",
-  "dist",
-  "coverage",
-  ".cache",
-  ".nyc_output"
-]);
 function runGraphCommand(args) {
   const sub = args[0];
   if (sub === void 0 || sub === "--help" || sub === "-h" || sub === "help") {
@@ -7299,8 +8114,9 @@ async function runBuildCommand(args) {
   console.log(`  branch:     ${branch ?? "(none / detached)"}`);
   console.log(`  output:     ${baseDir}`);
   console.log("");
-  const sourceFiles = discoverSourceFiles(cwd);
-  console.log(`Discovered ${sourceFiles.length} TypeScript source files. Extracting...`);
+  const ignoreConfig = loadGraphIgnore();
+  const sourceFiles = discoverSourceFiles(cwd, ignoreConfig);
+  console.log(`Discovered ${sourceFiles.length} source files. Extracting...`);
   const extractions = [];
   let skipped = 0;
   let totalParseErrors = 0;
@@ -7308,11 +8124,11 @@ async function runBuildCommand(args) {
   for (const abs of sourceFiles) {
     const rel = toForwardSlash(relative(cwd, abs));
     try {
-      const content = readFileSync20(abs, "utf8");
+      const content = readFileSync21(abs, "utf8");
       const contentSha = fileContentHash(content);
       let extraction = readCache(baseDir, contentSha, rel);
       if (extraction === null) {
-        extraction = extractTypeScript(content, rel);
+        extraction = extractFile(content, rel);
         writeCache(baseDir, contentSha, extraction);
       } else {
         cacheHits += 1;
@@ -7447,13 +8263,44 @@ async function runPullCommand(args) {
 function workTreeIdFor2(cwd) {
   return createHash6("sha256").update(cwd).digest("hex").slice(0, 16);
 }
-function discoverSourceFiles(rootDir) {
+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 = execSync3("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 = [];
-  walk(rootDir, out);
+  for (const rel of stdout.split("\0")) {
+    if (rel.length === 0)
+      continue;
+    if (!isSourceFile(rel))
+      continue;
+    if (pathHasIgnoredSegment(rel, ignore))
+      continue;
+    out.push(join28(rootDir, rel));
+  }
   out.sort();
   return out;
 }
-function walk(dir, out) {
+function walk(dir, out, ignore) {
   let entries;
   try {
     entries = readdirSync2(dir, { withFileTypes: true });
@@ -7461,13 +8308,13 @@ function walk(dir, out) {
     return;
   }
   for (const entry of entries) {
-    if (DEFAULT_IGNORES.has(entry.name))
+    if (ignore.has(entry.name))
       continue;
     if (entry.name.startsWith("."))
       continue;
-    const abs = join27(dir, entry.name);
+    const abs = join28(dir, entry.name);
     if (entry.isDirectory()) {
-      walk(abs, out);
+      walk(abs, out, ignore);
     } else if (entry.isFile() && isSourceFile(entry.name)) {
       out.push(abs);
     }
@@ -7476,7 +8323,7 @@ function walk(dir, out) {
 function isSourceFile(name) {
   if (name.endsWith(".d.ts"))
     return false;
-  return name.endsWith(".ts") || name.endsWith(".tsx");
+  return /\.(tsx?|jsx?|mjs|cjs|pyi?)$/.test(name);
 }
 function toForwardSlash(p) {
   return sep === "\\" ? p.replace(/\\/g, "/") : p;
@@ -7506,25 +8353,25 @@ function readGitBranch(cwd) {
 }
 
 // dist/src/commands/dashboard.js
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync19 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { dirname as dirname12, join as join35, resolve as resolve5 } from "node:path";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync20 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname12, join as join36, resolve as resolve5 } from "node:path";
 
 // dist/src/dashboard/data.js
-import { existsSync as existsSync25, readFileSync as readFileSync24, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join33 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync25, readdirSync as readdirSync4, statSync as statSync3 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join34 } from "node:path";
 
 // dist/src/notifications/sources/org-stats.js
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { dirname as dirname9, join as join28 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync22, writeFileSync as writeFileSync18 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { dirname as dirname9, join as join29 } from "node:path";
 var log5 = (msg) => log2("notifications-org-stats", msg);
 var FETCH_TIMEOUT_MS = 1500;
 var DEFAULT_API_URL3 = "https://api.deeplake.ai";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function cacheFilePath() {
-  return join28(homedir11(), ".deeplake", "hivemind-stats-cache.json");
+  return join29(homedir12(), ".deeplake", "hivemind-stats-cache.json");
 }
 var BALANCE_HEADER = "X-Activeloop-Balance-Cents";
 function parseBalanceHeader(resp) {
@@ -7553,7 +8400,7 @@ function readCache2(scopeKey) {
   if (!existsSync21(cacheFilePath()))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync21(cacheFilePath(), "utf-8"));
+    const parsed = JSON.parse(readFileSync22(cacheFilePath(), "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return {};
     if (parsed.scopeKey !== scopeKey)
@@ -7574,9 +8421,9 @@ function readCache2(scopeKey) {
 }
 function writeCache2(scopeKey, data) {
   try {
-    mkdirSync13(dirname9(cacheFilePath()), { recursive: true });
+    mkdirSync14(dirname9(cacheFilePath()), { recursive: true });
     const body = { fetchedAt: Date.now(), scopeKey, data };
-    writeFileSync17(cacheFilePath(), JSON.stringify(body), "utf-8");
+    writeFileSync18(cacheFilePath(), JSON.stringify(body), "utf-8");
   } catch (e) {
     log5(`cache write failed: ${e?.message ?? String(e)}`);
   }
@@ -7628,18 +8475,18 @@ async function fetchOrgStats(creds) {
 }
 
 // dist/src/notifications/usage-tracker.js
-import { appendFileSync as appendFileSync3, existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync22, readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname10, join as join29 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { appendFileSync as appendFileSync3, existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync23, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname10, join as join30 } from "node:path";
+import { homedir as homedir13 } from "node:os";
 var log6 = (msg) => log2("usage-tracker", msg);
 function statsFilePath() {
-  return join29(homedir12(), ".deeplake", "usage-stats.jsonl");
+  return join30(homedir13(), ".deeplake", "usage-stats.jsonl");
 }
 function readUsageRecords() {
   try {
     if (!existsSync22(statsFilePath()))
       return [];
-    const raw = readFileSync22(statsFilePath(), "utf-8");
+    const raw = readFileSync23(statsFilePath(), "utf-8");
     const out = [];
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -7676,7 +8523,7 @@ function sumMetric(records, key) {
 function countUserGeneratedSkills(userName) {
   if (!userName)
     return 0;
-  const dir = join29(homedir12(), ".claude", "skills");
+  const dir = join30(homedir13(), ".claude", "skills");
   if (!existsSync22(dir))
     return 0;
   const suffix = `--${userName}`;
@@ -7695,19 +8542,19 @@ function countUserGeneratedSkills(userName) {
 }
 
 // dist/src/skillify/state.js
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync18, writeSync, mkdirSync as mkdirSync15, renameSync as renameSync9, rmdirSync, existsSync as existsSync24, lstatSync as lstatSync3, unlinkSync as unlinkSync9, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync19, writeSync, mkdirSync as mkdirSync16, renameSync as renameSync9, rmdirSync, existsSync as existsSync24, lstatSync as lstatSync3, unlinkSync as unlinkSync9, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { join as join33 } from "node:path";
 
 // dist/src/skillify/legacy-migration.js
 import { existsSync as existsSync23, renameSync as renameSync8 } from "node:fs";
-import { dirname as dirname11, join as join31 } from "node:path";
+import { dirname as dirname11, join as join32 } from "node:path";
 
 // dist/src/skillify/state-dir.js
-import { homedir as homedir13 } from "node:os";
-import { join as join30 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join31 } from "node:path";
 function getStateDir() {
   const override = process.env.HIVEMIND_STATE_DIR?.trim();
-  return override && override.length > 0 ? override : join30(homedir13(), ".deeplake", "state", "skillify");
+  return override && override.length > 0 ? override : join31(homedir14(), ".deeplake", "state", "skillify");
 }
 
 // dist/src/skillify/legacy-migration.js
@@ -7720,7 +8567,7 @@ function migrateLegacyStateDir() {
     return;
   attempted = true;
   const current = getStateDir();
-  const legacy = join31(dirname11(current), "skilify");
+  const legacy = join32(dirname11(current), "skilify");
   if (!existsSync23(legacy))
     return;
   if (existsSync23(current))
@@ -7750,7 +8597,7 @@ var log7 = (msg) => log2("dashboard-data", msg);
 var BYTES_PER_TOKEN = 4;
 var SAVINGS_MULTIPLIER = 1.7;
 function graphsRoot2() {
-  return process.env.HIVEMIND_GRAPHS_HOME ?? join33(homedir14(), ".hivemind", "graphs");
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join34(homedir15(), ".hivemind", "graphs");
 }
 function bytesToSavedTokens(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0)
@@ -7759,16 +8606,16 @@ function bytesToSavedTokens(bytes) {
   return (SAVINGS_MULTIPLIER - 1) * delivered;
 }
 function resolveSnapshot(repoDir2) {
-  const snapshotsDir = join33(repoDir2, "snapshots");
+  const snapshotsDir = join34(repoDir2, "snapshots");
   if (!existsSync25(snapshotsDir))
     return null;
   let snapshotPath = null;
-  const pointer = join33(repoDir2, "latest-commit.txt");
+  const pointer = join34(repoDir2, "latest-commit.txt");
   if (existsSync25(pointer)) {
     try {
-      const sha = readFileSync24(pointer, "utf-8").trim();
+      const sha = readFileSync25(pointer, "utf-8").trim();
       if (sha) {
-        const candidate = join33(snapshotsDir, `${sha}.json`);
+        const candidate = join34(snapshotsDir, `${sha}.json`);
         if (existsSync25(candidate))
           snapshotPath = candidate;
         else
@@ -7781,7 +8628,7 @@ function resolveSnapshot(repoDir2) {
   if (!snapshotPath) {
     try {
       const candidates = readdirSync4(snapshotsDir).filter((name) => name.endsWith(".json")).map((name) => {
-        const full = join33(snapshotsDir, name);
+        const full = join34(snapshotsDir, name);
         return { full, mtime: statSync3(full).mtimeMs };
       }).sort((a, b) => b.mtime - a.mtime);
       if (candidates.length > 0)
@@ -7794,7 +8641,7 @@ function resolveSnapshot(repoDir2) {
     return null;
   let raw;
   try {
-    raw = readFileSync24(snapshotPath, "utf-8");
+    raw = readFileSync25(snapshotPath, "utf-8");
   } catch (e) {
     log7(`snapshot read failed: ${e?.message ?? String(e)}`);
     return null;
@@ -7864,7 +8711,7 @@ async function loadKpis(creds) {
 async function loadDashboardData(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const { key: repoKey, project: repoProject } = deriveProjectKey(cwd);
-  const repoDir2 = join33(opts.graphsHome ?? graphsRoot2(), repoKey);
+  const repoDir2 = join34(opts.graphsHome ?? graphsRoot2(), repoKey);
   const graph = resolveSnapshot(repoDir2);
   const creds = opts.creds === void 0 ? loadCredentials() : opts.creds;
   const kpis = await loadKpis(creds);
@@ -7881,7 +8728,7 @@ async function loadDashboardData(opts = {}) {
 import { spawn } from "node:child_process";
 import { accessSync, constants as fsConstants, statSync as statSync4 } from "node:fs";
 import { platform as nodePlatform } from "node:os";
-import { delimiter, join as join34 } from "node:path";
+import { delimiter, join as join35 } from "node:path";
 function resolveOpenPlatform() {
   const p = nodePlatform();
   if (p === "linux" || p === "darwin" || p === "win32")
@@ -7908,7 +8755,7 @@ function findBinaryOnPath(name) {
     if (!dir)
       continue;
     for (const ext of exts) {
-      const candidate = join34(dir, name + ext);
+      const candidate = join35(dir, name + ext);
       try {
         const st = statSync4(candidate);
         if (!st.isFile())
@@ -8000,8 +8847,8 @@ function transformSnapshotToVis(snapshot) {
       if (kind)
         titleParts.push(kind);
       if (sourceFile) {
-        const loc = sourceLoc ? `${sourceFile}:${sourceLoc}` : sourceFile;
-        titleParts.push(loc);
+        const loc2 = sourceLoc ? `${sourceFile}:${sourceLoc}` : sourceFile;
+        titleParts.push(loc2);
       }
       const color = kind && KIND_COLORS[kind] ? KIND_COLORS[kind] : DEFAULT_NODE_COLOR;
       visNodes.push({
@@ -8418,7 +9265,7 @@ function parseDashboardArgs(args) {
   };
 }
 function defaultDashboardOutPath(repoKey) {
-  return join35(homedir15(), ".hivemind", "dashboards", repoKey, "index.html");
+  return join36(homedir16(), ".hivemind", "dashboards", repoKey, "index.html");
 }
 async function runDashboardCommand(rawArgs, runOpts = {}) {
   const out = runOpts.out ?? ((s) => {
@@ -8452,8 +9299,8 @@ async function runDashboardCommand(rawArgs, runOpts = {}) {
   const finalOut = outPath || defaultDashboardOutPath(data.repoKey);
   const absOut = resolve5(finalOut);
   try {
-    mkdirSync16(dirname12(absOut), { recursive: true });
-    writeFileSync19(absOut, html, "utf-8");
+    mkdirSync17(dirname12(absOut), { recursive: true });
+    writeFileSync20(absOut, html, "utf-8");
   } catch (e) {
     err(`hivemind dashboard: failed to write ${absOut}: ${e?.message ?? String(e)}
 `);
@@ -8532,15 +9379,15 @@ function defaultOnSignal(signal, handler) {
 }
 
 // dist/src/commands/skillify.js
-import { readdirSync as readdirSync8, existsSync as existsSync36, readFileSync as readFileSync32, mkdirSync as mkdirSync23, renameSync as renameSync12 } from "node:fs";
-import { homedir as homedir24 } from "node:os";
-import { dirname as dirname17, join as join46 } from "node:path";
+import { readdirSync as readdirSync8, existsSync as existsSync36, readFileSync as readFileSync33, mkdirSync as mkdirSync24, renameSync as renameSync12 } from "node:fs";
+import { homedir as homedir25 } from "node:os";
+import { dirname as dirname17, join as join47 } from "node:path";
 
 // dist/src/skillify/scope-config.js
-import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync18, readFileSync as readFileSync26, writeFileSync as writeFileSync21 } from "node:fs";
+import { join as join37 } from "node:path";
 function configPath() {
-  return join36(getStateDir(), "config.json");
+  return join37(getStateDir(), "config.json");
 }
 var DEFAULT = { scope: "me", team: [], install: "project" };
 function loadScopeConfig() {
@@ -8549,7 +9396,7 @@ function loadScopeConfig() {
   if (!existsSync26(CONFIG_PATH2))
     return DEFAULT;
   try {
-    const raw = JSON.parse(readFileSync25(CONFIG_PATH2, "utf-8"));
+    const raw = JSON.parse(readFileSync26(CONFIG_PATH2, "utf-8"));
     const scope = raw.scope === "team" ? "team" : raw.scope === "org" ? "team" : "me";
     const team = Array.isArray(raw.team) ? raw.team.filter((s) => typeof s === "string") : [];
     const install = raw.install === "global" ? "global" : "project";
@@ -8560,19 +9407,19 @@ function loadScopeConfig() {
 }
 function saveScopeConfig(cfg) {
   migrateLegacyStateDir();
-  mkdirSync17(getStateDir(), { recursive: true });
-  writeFileSync20(configPath(), JSON.stringify(cfg, null, 2));
+  mkdirSync18(getStateDir(), { recursive: true });
+  writeFileSync21(configPath(), JSON.stringify(cfg, null, 2));
 }
 
 // dist/src/skillify/pull.js
-import { existsSync as existsSync30, readFileSync as readFileSync28, writeFileSync as writeFileSync23, mkdirSync as mkdirSync20, renameSync as renameSync11, lstatSync as lstatSync5, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync11 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { dirname as dirname14, join as join40 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync29, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, renameSync as renameSync11, lstatSync as lstatSync5, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync11 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import { dirname as dirname14, join as join41 } from "node:path";
 
 // dist/src/skillify/skill-writer.js
-import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync21 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { join as join37 } from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync19, readFileSync as readFileSync27, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync22 } from "node:fs";
+import { homedir as homedir17 } from "node:os";
+import { join as join38 } from "node:path";
 function assertValidSkillName(name) {
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`invalid skill name: empty or non-string`);
@@ -8588,10 +9435,10 @@ function assertValidSkillName(name) {
   }
 }
 function skillDir(skillsRoot, name) {
-  return join37(skillsRoot, name);
+  return join38(skillsRoot, name);
 }
 function skillPath(skillsRoot, name) {
-  return join37(skillDir(skillsRoot, name), "SKILL.md");
+  return join38(skillDir(skillsRoot, name), "SKILL.md");
 }
 function renderFrontmatter(fm) {
   const lines = ["---"];
@@ -8672,7 +9519,7 @@ function writeNewSkill(args) {
   if (existsSync27(path)) {
     throw new Error(`skill already exists at ${path}; use mergeSkill`);
   }
-  mkdirSync18(dir, { recursive: true });
+  mkdirSync19(dir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const author = args.author && args.author.length > 0 ? args.author : void 0;
   const contributors = author ? [author] : [];
@@ -8692,7 +9539,7 @@ function writeNewSkill(args) {
 
 ${args.body.trim()}
 `;
-  writeFileSync21(path, text);
+  writeFileSync22(path, text);
   return {
     path,
     action: "created",
@@ -8708,28 +9555,28 @@ function listSkills(skillsRoot) {
     return [];
   const out = [];
   for (const name of readdirSync5(skillsRoot)) {
-    const skillFile = join37(skillsRoot, name, "SKILL.md");
+    const skillFile = join38(skillsRoot, name, "SKILL.md");
     if (existsSync27(skillFile) && statSync5(skillFile).isFile()) {
-      out.push({ name, body: readFileSync26(skillFile, "utf-8") });
+      out.push({ name, body: readFileSync27(skillFile, "utf-8") });
     }
   }
   return out;
 }
 function resolveSkillsRoot(install, cwd) {
   if (install === "global") {
-    return join37(homedir16(), ".claude", "skills");
+    return join38(homedir17(), ".claude", "skills");
   }
-  return join37(cwd, ".claude", "skills");
+  return join38(cwd, ".claude", "skills");
 }
 
 // dist/src/skillify/manifest.js
-import { existsSync as existsSync28, lstatSync as lstatSync4, mkdirSync as mkdirSync19, readFileSync as readFileSync27, renameSync as renameSync10, unlinkSync as unlinkSync10, writeFileSync as writeFileSync22 } from "node:fs";
-import { dirname as dirname13, join as join38 } from "node:path";
+import { existsSync as existsSync28, lstatSync as lstatSync4, mkdirSync as mkdirSync20, readFileSync as readFileSync28, renameSync as renameSync10, unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "node:fs";
+import { dirname as dirname13, join as join39 } from "node:path";
 function emptyManifest() {
   return { version: 1, entries: [] };
 }
 function manifestPath() {
-  return join38(getStateDir(), "pulled.json");
+  return join39(getStateDir(), "pulled.json");
 }
 function loadManifest(path = manifestPath()) {
   migrateLegacyStateDir();
@@ -8737,7 +9584,7 @@ function loadManifest(path = manifestPath()) {
     return emptyManifest();
   let raw;
   try {
-    raw = readFileSync27(path, "utf-8");
+    raw = readFileSync28(path, "utf-8");
   } catch {
     return emptyManifest();
   }
@@ -8784,9 +9631,9 @@ function loadManifest(path = manifestPath()) {
 }
 function saveManifest(m, path = manifestPath()) {
   migrateLegacyStateDir();
-  mkdirSync19(dirname13(path), { recursive: true });
+  mkdirSync20(dirname13(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  writeFileSync22(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  writeFileSync23(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
   renameSync10(tmp, path);
 }
 function recordPull(entry, path = manifestPath()) {
@@ -8829,7 +9676,7 @@ function pruneOrphanedEntries(path = manifestPath()) {
   const live = [];
   let pruned = 0;
   for (const e of m.entries) {
-    if (existsSync28(join38(e.installRoot, e.dirName))) {
+    if (existsSync28(join39(e.installRoot, e.dirName))) {
       live.push(e);
       continue;
     }
@@ -8843,25 +9690,25 @@ function pruneOrphanedEntries(path = manifestPath()) {
 
 // dist/src/skillify/agent-roots.js
 import { existsSync as existsSync29 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { join as join39 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { join as join40 } from "node:path";
 function resolveDetected(home) {
   const out = [];
-  const codexInstalled = existsSync29(join39(home, ".codex"));
-  const piInstalled = existsSync29(join39(home, ".pi", "agent"));
-  const hermesInstalled = existsSync29(join39(home, ".hermes"));
+  const codexInstalled = existsSync29(join40(home, ".codex"));
+  const piInstalled = existsSync29(join40(home, ".pi", "agent"));
+  const hermesInstalled = existsSync29(join40(home, ".hermes"));
   if (codexInstalled || piInstalled) {
-    out.push(join39(home, ".agents", "skills"));
+    out.push(join40(home, ".agents", "skills"));
   }
   if (hermesInstalled) {
-    out.push(join39(home, ".hermes", "skills"));
+    out.push(join40(home, ".hermes", "skills"));
   }
   if (piInstalled) {
-    out.push(join39(home, ".pi", "agent", "skills"));
+    out.push(join40(home, ".pi", "agent", "skills"));
   }
   return out;
 }
-function detectAgentSkillsRoots(canonicalRoot, home = homedir17()) {
+function detectAgentSkillsRoots(canonicalRoot, home = homedir18()) {
   return resolveDetected(home).filter((p) => p !== canonicalRoot);
 }
 
@@ -8905,15 +9752,15 @@ function isMissingTableError2(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join40(homedir18(), ".claude", "skills");
+    return join41(homedir19(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join40(cwd, ".claude", "skills");
+  return join41(cwd, ".claude", "skills");
 }
 function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
   const out = [];
   for (const root of agentRoots) {
-    const link = join40(root, dirName);
+    const link = join41(root, dirName);
     let existing;
     try {
       existing = lstatSync5(link);
@@ -8941,7 +9788,7 @@ function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
       }
     }
     try {
-      mkdirSync20(dirname14(link), { recursive: true });
+      mkdirSync21(dirname14(link), { recursive: true });
       symlinkSync2(canonicalDir, link, "dir");
       out.push(link);
     } catch {
@@ -8956,7 +9803,7 @@ function backfillSymlinks(installRoot) {
     return;
   const detected = detectAgentSkillsRoots(installRoot);
   for (const entry of entries) {
-    const canonical = join40(entry.installRoot, entry.dirName);
+    const canonical = join41(entry.installRoot, entry.dirName);
     if (!existsSync30(canonical))
       continue;
     const fresh = fanOutSymlinks(canonical, entry.dirName, detected);
@@ -9070,7 +9917,7 @@ function readLocalVersion(path) {
   if (!existsSync30(path))
     return null;
   try {
-    const text = readFileSync28(path, "utf-8");
+    const text = readFileSync29(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -9169,8 +10016,8 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const skillDir2 = join40(root, dirName);
-    const skillFile = join40(skillDir2, "SKILL.md");
+    const skillDir2 = join41(root, dirName);
+    const skillFile = join41(skillDir2, "SKILL.md");
     const remoteVersion = Number(row.version ?? 1);
     const localVersion = readLocalVersion(skillFile);
     const action = decideAction({
@@ -9181,14 +10028,14 @@ async function runPull(opts) {
     });
     let manifestError;
     if (action === "wrote") {
-      mkdirSync20(skillDir2, { recursive: true });
+      mkdirSync21(skillDir2, { recursive: true });
       if (existsSync30(skillFile)) {
         try {
           renameSync11(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync23(skillFile, renderSkillFile(row));
+      writeFileSync24(skillFile, renderSkillFile(row));
       const symlinks = opts.install === "global" ? fanOutSymlinks(skillDir2, dirName, detectAgentSkillsRoots(root)) : [];
       try {
         recordPull({
@@ -9231,14 +10078,14 @@ async function runPull(opts) {
 
 // dist/src/skillify/unpull.js
 import { existsSync as existsSync31, readdirSync as readdirSync6, rmSync as rmSync5, statSync as statSync6 } from "node:fs";
-import { homedir as homedir19 } from "node:os";
-import { join as join41 } from "node:path";
+import { homedir as homedir20 } from "node:os";
+import { join as join42 } from "node:path";
 function resolveUnpullRoot(install, cwd) {
   if (install === "global")
-    return join41(homedir19(), ".claude", "skills");
+    return join42(homedir20(), ".claude", "skills");
   if (!cwd)
     throw new Error("cwd required when install === 'project'");
-  return join41(cwd, ".claude", "skills");
+  return join42(cwd, ".claude", "skills");
 }
 function runUnpull(opts) {
   const root = resolveUnpullRoot(opts.install, opts.cwd);
@@ -9261,7 +10108,7 @@ function runUnpull(opts) {
   const entries = entriesForRoot(manifest, opts.install, root);
   for (const entry of entries) {
     summary.scanned++;
-    const path = join41(root, entry.dirName);
+    const path = join42(root, entry.dirName);
     if (!existsSync31(path)) {
       if (!opts.dryRun) {
         unlinkSymlinks(entry.symlinks);
@@ -9320,7 +10167,7 @@ function runUnpull(opts) {
     for (const dirName of readdirSync6(root)) {
       if (manifestDirNames.has(dirName))
         continue;
-      const path = join41(root, dirName);
+      const path = join42(root, dirName);
       let st;
       try {
         st = statSync6(path);
@@ -9399,21 +10246,21 @@ function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
 
 // dist/src/commands/mine-local.js
 import { spawn as spawn2 } from "node:child_process";
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "node:fs";
-import { homedir as homedir23 } from "node:os";
-import { basename as basename2, dirname as dirname16, join as join45 } from "node:path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync23, readFileSync as readFileSync32, writeFileSync as writeFileSync26 } from "node:fs";
+import { homedir as homedir24 } from "node:os";
+import { basename as basename2, dirname as dirname16, join as join46 } from "node:path";
 
 // dist/src/skillify/local-source.js
-import { readdirSync as readdirSync7, readFileSync as readFileSync29, existsSync as existsSync32, statSync as statSync7 } from "node:fs";
-import { homedir as homedir20 } from "node:os";
-import { join as join42 } from "node:path";
-var HOME2 = homedir20();
+import { readdirSync as readdirSync7, readFileSync as readFileSync30, existsSync as existsSync32, statSync as statSync7 } from "node:fs";
+import { homedir as homedir21 } from "node:os";
+import { join as join43 } from "node:path";
+var HOME2 = homedir21();
 function encodeCwdClaudeCode(cwd) {
   return cwd.replace(/[/_]/g, "-");
 }
 function detectInstalledAgents() {
   const installs = [];
-  const claudeRoot = join42(HOME2, ".claude", "projects");
+  const claudeRoot = join43(HOME2, ".claude", "projects");
   if (existsSync32(claudeRoot)) {
     installs.push({
       agent: "claude_code",
@@ -9421,7 +10268,7 @@ function detectInstalledAgents() {
       encodeCwd: encodeCwdClaudeCode
     });
   }
-  const codexRoot = join42(HOME2, ".codex", "sessions");
+  const codexRoot = join43(HOME2, ".codex", "sessions");
   if (existsSync32(codexRoot)) {
     installs.push({
       agent: "codex",
@@ -9449,7 +10296,7 @@ function listLocalSessions(installs, cwd) {
       continue;
     }
     for (const sub of subdirs) {
-      const subdirPath = join42(install.sessionRoot, sub);
+      const subdirPath = join43(install.sessionRoot, sub);
       try {
         if (!statSync7(subdirPath).isDirectory())
           continue;
@@ -9466,7 +10313,7 @@ function listLocalSessions(installs, cwd) {
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const fullPath = join42(subdirPath, f);
+        const fullPath = join43(subdirPath, f);
         let stats;
         try {
           stats = statSync7(fullPath);
@@ -9527,7 +10374,7 @@ function pickSessions(candidates, opts) {
 function nativeJsonlToRows(filePath, sessionId, agent) {
   let raw;
   try {
-    raw = readFileSync29(filePath, "utf-8");
+    raw = readFileSync30(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -9619,8 +10466,8 @@ function extractPairs(rows) {
 // dist/src/skillify/gate-runner.js
 import { existsSync as existsSync33 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir21 } from "node:os";
-import { join as join43 } from "node:path";
+import { homedir as homedir22 } from "node:os";
+import { join as join44 } from "node:path";
 var requireForCp = createRequire(import.meta.url);
 var { execFileSync: runChildProcess } = requireForCp("node:child_process");
 var inheritedEnv = process;
@@ -9632,7 +10479,7 @@ function firstExistingPath(candidates) {
   return null;
 }
 function findAgentBin(agent) {
-  const home = homedir21();
+  const home = homedir22();
   switch (agent) {
     // /usr/bin/<name> is included in every candidate list — that's the
     // common Linux package-manager install path (apt, dnf, pacman). Old
@@ -9641,45 +10488,45 @@ function findAgentBin(agent) {
     // #170 caught the gap.
     case "claude_code":
       return firstExistingPath([
-        join43(home, ".claude", "local", "claude"),
+        join44(home, ".claude", "local", "claude"),
         "/usr/local/bin/claude",
         "/usr/bin/claude",
-        join43(home, ".npm-global", "bin", "claude"),
-        join43(home, ".local", "bin", "claude"),
+        join44(home, ".npm-global", "bin", "claude"),
+        join44(home, ".local", "bin", "claude"),
         "/opt/homebrew/bin/claude"
-      ]) ?? join43(home, ".claude", "local", "claude");
+      ]) ?? join44(home, ".claude", "local", "claude");
     case "codex":
       return firstExistingPath([
         "/usr/local/bin/codex",
         "/usr/bin/codex",
-        join43(home, ".npm-global", "bin", "codex"),
-        join43(home, ".local", "bin", "codex"),
+        join44(home, ".npm-global", "bin", "codex"),
+        join44(home, ".local", "bin", "codex"),
         "/opt/homebrew/bin/codex"
       ]) ?? "/usr/local/bin/codex";
     case "cursor":
       return firstExistingPath([
         "/usr/local/bin/cursor-agent",
         "/usr/bin/cursor-agent",
-        join43(home, ".npm-global", "bin", "cursor-agent"),
-        join43(home, ".local", "bin", "cursor-agent"),
+        join44(home, ".npm-global", "bin", "cursor-agent"),
+        join44(home, ".local", "bin", "cursor-agent"),
         "/opt/homebrew/bin/cursor-agent"
       ]) ?? "/usr/local/bin/cursor-agent";
     case "hermes":
       return firstExistingPath([
-        join43(home, ".local", "bin", "hermes"),
+        join44(home, ".local", "bin", "hermes"),
         "/usr/local/bin/hermes",
         "/usr/bin/hermes",
-        join43(home, ".npm-global", "bin", "hermes"),
+        join44(home, ".npm-global", "bin", "hermes"),
         "/opt/homebrew/bin/hermes"
-      ]) ?? join43(home, ".local", "bin", "hermes");
+      ]) ?? join44(home, ".local", "bin", "hermes");
     case "pi":
       return firstExistingPath([
-        join43(home, ".local", "bin", "pi"),
+        join44(home, ".local", "bin", "pi"),
         "/usr/local/bin/pi",
         "/usr/bin/pi",
-        join43(home, ".npm-global", "bin", "pi"),
+        join44(home, ".npm-global", "bin", "pi"),
         "/opt/homebrew/bin/pi"
-      ]) ?? join43(home, ".local", "bin", "pi");
+      ]) ?? join44(home, ".local", "bin", "pi");
   }
 }
 
@@ -9709,23 +10556,23 @@ function extractJsonBlock(s) {
 }
 
 // dist/src/skillify/local-manifest.js
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync24 } from "node:fs";
-import { homedir as homedir22 } from "node:os";
-import { dirname as dirname15, join as join44 } from "node:path";
-var LOCAL_MANIFEST_PATH = join44(homedir22(), ".claude", "hivemind", "local-mined.json");
-var LOCAL_MINE_LOCK_PATH = join44(homedir22(), ".claude", "hivemind", "local-mined.lock");
+import { existsSync as existsSync34, mkdirSync as mkdirSync22, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "node:fs";
+import { homedir as homedir23 } from "node:os";
+import { dirname as dirname15, join as join45 } from "node:path";
+var LOCAL_MANIFEST_PATH = join45(homedir23(), ".claude", "hivemind", "local-mined.json");
+var LOCAL_MINE_LOCK_PATH = join45(homedir23(), ".claude", "hivemind", "local-mined.lock");
 function readLocalManifest(path = LOCAL_MANIFEST_PATH) {
   if (!existsSync34(path))
     return null;
   try {
-    return JSON.parse(readFileSync30(path, "utf-8"));
+    return JSON.parse(readFileSync31(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLocalManifest(m, path = LOCAL_MANIFEST_PATH) {
-  mkdirSync21(dirname15(path), { recursive: true });
-  writeFileSync24(path, JSON.stringify(m, null, 2));
+  mkdirSync22(dirname15(path), { recursive: true });
+  writeFileSync25(path, JSON.stringify(m, null, 2));
 }
 function countLocalManifestEntries(path = LOCAL_MANIFEST_PATH) {
   const m = readLocalManifest(path);
@@ -10159,8 +11006,8 @@ async function runMineLocalImpl(args) {
     console.log(`Dry-run: would invoke ${gateAgent} gate on ${picked.length} session(s) in parallel (concurrency=${GATE_CONCURRENCY}).`);
     return;
   }
-  const tmpDir = join45(homedir23(), ".claude", "hivemind", `mine-local-${Date.now()}`);
-  mkdirSync22(tmpDir, { recursive: true });
+  const tmpDir = join46(homedir24(), ".claude", "hivemind", `mine-local-${Date.now()}`);
+  mkdirSync23(tmpDir, { recursive: true });
   console.log(`Running ${picked.length} gate call(s) in parallel (concurrency=${GATE_CONCURRENCY}, timeout=${GATE_TIMEOUT_MS / 1e3}s each)...`);
   const results = await parallelMap(picked, GATE_CONCURRENCY, async (s) => {
     const shortId = s.sessionId.slice(0, 8);
@@ -10171,23 +11018,23 @@ async function runMineLocalImpl(args) {
       return { session: s, skills: [], reason: "no pairs", error: null };
     }
     const tail = pairs2.slice(-PER_SESSION_PAIR_CAP);
-    const sessionTmp = join45(tmpDir, `s-${shortId}`);
-    mkdirSync22(sessionTmp, { recursive: true });
-    const verdictPath = join45(sessionTmp, "verdict.json");
+    const sessionTmp = join46(tmpDir, `s-${shortId}`);
+    mkdirSync23(sessionTmp, { recursive: true });
+    const verdictPath = join46(sessionTmp, "verdict.json");
     const prompt = buildSessionPrompt(tail, s, verdictPath);
-    writeFileSync25(join45(sessionTmp, "prompt.txt"), prompt);
+    writeFileSync26(join46(sessionTmp, "prompt.txt"), prompt);
     const gate = await runGateViaStdin({ agent: gateAgent, bin: gateBin, prompt, timeoutMs: GATE_TIMEOUT_MS });
     try {
-      writeFileSync25(join45(sessionTmp, "gate-stdout.txt"), gate.stdout);
+      writeFileSync26(join46(sessionTmp, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync25(join45(sessionTmp, "gate-stderr.txt"), gate.stderr);
+        writeFileSync26(join46(sessionTmp, "gate-stderr.txt"), gate.stderr);
     } catch {
     }
     if (gate.errored) {
       console.log(`  [${shortId}] gate failed: ${gate.errorMessage}`);
       return { session: s, skills: [], reason: null, error: gate.errorMessage ?? "gate failed" };
     }
-    const verdictText = existsSync35(verdictPath) ? readFileSync31(verdictPath, "utf-8") : gate.stdout;
+    const verdictText = existsSync35(verdictPath) ? readFileSync32(verdictPath, "utf-8") : gate.stdout;
     const mv = parseMultiVerdict(verdictText);
     if (!mv) {
       console.log(`  [${shortId}] unparseable verdict (kept at ${sessionTmp})`);
@@ -10428,7 +11275,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync32(join46(dir, f), "utf-8"));
+      const s = JSON.parse(readFileSync33(join47(dir, f), "utf-8"));
       const last = typeof s.updatedAt === "number" ? new Date(s.updatedAt).toISOString() : s.lastDate ?? "never";
       const skills = Array.isArray(s.skillsGenerated) && s.skillsGenerated.length > 0 ? s.skillsGenerated.join(", ") : "none";
       console.log(`  - ${s.project} (counter=${s.counter}, last=${last}, skills=${skills})`);
@@ -10448,32 +11295,32 @@ function setScope(scope) {
     console.log(`Note: team list is empty. Use 'hivemind skillify team add <username>' to populate it.`);
   }
 }
-function setInstall(loc) {
-  if (loc !== "project" && loc !== "global") {
-    console.error(`Invalid install location '${loc}'. Use one of: project, global`);
+function setInstall(loc2) {
+  if (loc2 !== "project" && loc2 !== "global") {
+    console.error(`Invalid install location '${loc2}'. Use one of: project, global`);
     process.exit(1);
   }
   const cfg = loadScopeConfig();
-  saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join46(homedir24(), ".claude", "skills") : "<cwd>/.claude/skills";
-  console.log(`Install location set to '${loc}'. New skills will be written to ${path}/<name>/SKILL.md.`);
+  saveScopeConfig({ ...cfg, install: loc2 });
+  const path = loc2 === "global" ? join47(homedir25(), ".claude", "skills") : "<cwd>/.claude/skills";
+  console.log(`Install location set to '${loc2}'. New skills will be written to ${path}/<name>/SKILL.md.`);
 }
 function promoteSkill(name, cwd) {
   if (!name) {
     console.error("Usage: hivemind skillify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join46(cwd, ".claude", "skills", name);
-  const globalPath = join46(homedir24(), ".claude", "skills", name);
-  if (!existsSync36(join46(projectPath, "SKILL.md"))) {
+  const projectPath = join47(cwd, ".claude", "skills", name);
+  const globalPath = join47(homedir25(), ".claude", "skills", name);
+  if (!existsSync36(join47(projectPath, "SKILL.md"))) {
     console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
     process.exit(1);
   }
-  if (existsSync36(join46(globalPath, "SKILL.md"))) {
+  if (existsSync36(join47(globalPath, "SKILL.md"))) {
     console.error(`Skill '${name}' already exists at ${globalPath}/SKILL.md \u2014 refusing to overwrite. Remove it first or rename the project skill.`);
     process.exit(1);
   }
-  mkdirSync23(dirname17(globalPath), { recursive: true });
+  mkdirSync24(dirname17(globalPath), { recursive: true });
   renameSync12(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
@@ -10580,7 +11427,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join46(homedir24(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join47(homedir25(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterDesc = users.length === 0 ? "all users" : users.join(", ");
   console.log(`Destination: ${dest}`);
   console.log(`Filter:      ${filterDesc}${skillName ? ` \xB7 skill='${skillName}'` : ""}${dryRun ? " \xB7 dry-run" : ""}${force ? " \xB7 force" : ""}`);
@@ -10630,7 +11477,7 @@ async function unpullSkills(args) {
     all,
     legacyCleanup
   });
-  const dest = toRaw === "global" ? join46(homedir24(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join47(homedir25(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterParts = [];
   if (users.length > 0)
     filterParts.push(`users=${users.join(",")}`);
@@ -11498,14 +12345,14 @@ async function runContextCommand(args) {
 
 // dist/src/cli/update.js
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync37, mkdirSync as mkdirSync24, openSync as openSync3, readFileSync as readFileSync34, realpathSync, unlinkSync as unlinkSync13, writeSync as writeSync2 } from "node:fs";
-import { homedir as homedir25 } from "node:os";
-import { dirname as dirname19, join as join48, sep as sep2 } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync37, mkdirSync as mkdirSync25, openSync as openSync3, readFileSync as readFileSync35, realpathSync, unlinkSync as unlinkSync13, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir26 } from "node:os";
+import { dirname as dirname19, join as join49, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/src/utils/version-check.js
-import { readFileSync as readFileSync33 } from "node:fs";
-import { dirname as dirname18, join as join47 } from "node:path";
+import { readFileSync as readFileSync34 } from "node:fs";
+import { dirname as dirname18, join as join48 } from "node:path";
 function isNewer(latest, current) {
   const parse = (v) => v.split(".").map(Number);
   const [la, lb, lc] = parse(latest);
@@ -11517,7 +12364,7 @@ function isNewer(latest, current) {
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@deeplake/hivemind/latest";
 var PKG_NAME = "@deeplake/hivemind";
 function defaultLockPath() {
-  return join48(homedir25(), ".deeplake", "hivemind-update.lock");
+  return join49(homedir26(), ".deeplake", "hivemind-update.lock");
 }
 function detectInstallKind(argv1) {
   const realArgv1 = (() => {
@@ -11532,7 +12379,7 @@ function detectInstallKind(argv1) {
   for (let i = 0; i < 10; i++) {
     const pkgPath = `${dir}${sep2}package.json`;
     try {
-      const pkg = JSON.parse(readFileSync34(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync35(pkgPath, "utf-8"));
       if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
         installDir = dir;
         break;
@@ -11578,7 +12425,7 @@ var defaultSpawn = (cmd, args) => {
   execFileSync6(cmd, args, { stdio: "inherit" });
 };
 function tryAcquireLock(path) {
-  mkdirSync24(dirname19(path), { recursive: true, mode: 448 });
+  mkdirSync25(dirname19(path), { recursive: true, mode: 448 });
   const claim = () => {
     const fd = openSync3(path, "wx", 384);
     writeSync2(fd, String(process.pid));
@@ -11592,7 +12439,7 @@ function tryAcquireLock(path) {
   }
   let holderPid = 0;
   try {
-    holderPid = Number(readFileSync34(path, "utf-8").trim()) || 0;
+    holderPid = Number(readFileSync35(path, "utf-8").trim()) || 0;
   } catch {
     try {
       return claim();
@@ -11720,9 +12567,9 @@ async function runUpdate(opts = {}) {
 
 // dist/src/cli/install-scan.js
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync39, readFileSync as readFileSync35, readdirSync as readdirSync9, unlinkSync as unlinkSync14 } from "node:fs";
-import { homedir as homedir26 } from "node:os";
-import { join as join49 } from "node:path";
+import { existsSync as existsSync39, readFileSync as readFileSync36, readdirSync as readdirSync9, unlinkSync as unlinkSync14 } from "node:fs";
+import { homedir as homedir27 } from "node:os";
+import { join as join50 } from "node:path";
 
 // dist/src/skillify/advisor.js
 import { spawn as spawn3 } from "node:child_process";
@@ -11885,10 +12732,10 @@ async function runAdvisor(manifestPath3 = LOCAL_MANIFEST_PATH) {
 
 // dist/src/cli/install-scan.js
 function claudeProjectsDir() {
-  return join49(homedir26(), ".claude", "projects");
+  return join50(homedir27(), ".claude", "projects");
 }
 function manifestPath2() {
-  return join49(homedir26(), ".claude", "hivemind", "local-mined.json");
+  return join50(homedir27(), ".claude", "hivemind", "local-mined.json");
 }
 var SCAN_TIMEOUT_MS = 3e5;
 var INSTALL_SCAN_SESSION_COUNT = 10;
@@ -11897,7 +12744,7 @@ function manifestIsTrulyEmpty() {
   if (!existsSync39(p))
     return false;
   try {
-    const m = JSON.parse(readFileSync35(p, "utf-8"));
+    const m = JSON.parse(readFileSync36(p, "utf-8"));
     return Array.isArray(m.entries) && m.entries.length === 0;
   } catch {
     return false;
@@ -11916,7 +12763,7 @@ function hasLocalClaudeSessions() {
   for (const sub of subdirs) {
     let files;
     try {
-      files = readdirSync9(join49(projectsDir, sub));
+      files = readdirSync9(join50(projectsDir, sub));
     } catch {
       continue;
     }