@deeplake/hivemind 0.7.31 → 0.7.33

package/bundle/cli.js

@@ -17,21 +17,21 @@ __export(index_marker_store_exports, {
   hasFreshIndexMarker: () => hasFreshIndexMarker,
   writeIndexMarker: () => writeIndexMarker
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join18 } from "node:path";
 import { tmpdir } from "node:os";
 function getIndexMarkerDir() {
-  return process.env.HIVEMIND_INDEX_MARKER_DIR ?? join16(tmpdir(), "hivemind-deeplake-indexes");
+  return process.env.HIVEMIND_INDEX_MARKER_DIR ?? join18(tmpdir(), "hivemind-deeplake-indexes");
 }
 function buildIndexMarkerPath(workspaceId, orgId, table, suffix) {
   const markerKey = [workspaceId, orgId, table, suffix].join("__").replace(/[^a-zA-Z0-9_.-]/g, "_");
-  return join16(getIndexMarkerDir(), `${markerKey}.json`);
+  return join18(getIndexMarkerDir(), `${markerKey}.json`);
 }
 function hasFreshIndexMarker(markerPath) {
-  if (!existsSync13(markerPath))
+  if (!existsSync14(markerPath))
     return false;
   try {
-    const raw = JSON.parse(readFileSync10(markerPath, "utf-8"));
+    const raw = JSON.parse(readFileSync13(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;
@@ -41,8 +41,8 @@ function hasFreshIndexMarker(markerPath) {
   }
 }
 function writeIndexMarker(markerPath) {
-  mkdirSync3(getIndexMarkerDir(), { recursive: true });
-  writeFileSync7(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
+  mkdirSync5(getIndexMarkerDir(), { recursive: true });
+  writeFileSync9(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
 }
 var INDEX_MARKER_TTL_MS;
 var init_index_marker_store = __esm({
@@ -3681,42 +3681,137 @@ function uninstallPi() {
 }
 
 // dist/src/cli/embeddings.js
-import { copyFileSync as copyFileSync3, chmodSync, existsSync as existsSync10, lstatSync as lstatSync2, readdirSync, readlinkSync, rmSync as rmSync4, statSync, unlinkSync as unlinkSync5 } from "node:fs";
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { join as join11 } from "node:path";
-var SHARED_DIR = join11(HOME, ".hivemind", "embed-deps");
-var SHARED_NODE_MODULES = join11(SHARED_DIR, "node_modules");
-var SHARED_DAEMON_PATH = join11(SHARED_DIR, "embed-daemon.js");
+import { copyFileSync as copyFileSync3, chmodSync, existsSync as existsSync11, lstatSync as lstatSync2, readdirSync, readFileSync as readFileSync9, readlinkSync, rmSync as rmSync4, statSync, unlinkSync as unlinkSync5 } from "node:fs";
+import { execFileSync as execFileSync3, spawnSync } from "node:child_process";
+import { userInfo } from "node:os";
+import { join as join12 } from "node:path";
+
+// dist/src/embeddings/protocol.js
+var DEFAULT_SOCKET_DIR = "/tmp";
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+function socketPathFor(uid, dir = DEFAULT_SOCKET_DIR) {
+  return `${dir}/hivemind-embed-${uid}.sock`;
+}
+function pidPathFor(uid, dir = DEFAULT_SOCKET_DIR) {
+  return `${dir}/hivemind-embed-${uid}.pid`;
+}
+
+// dist/src/user-config.js
+import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname2, join as join11 } from "node:path";
+var _configPath = () => process.env.HIVEMIND_CONFIG_PATH ?? join11(homedir4(), ".deeplake", "config.json");
+var _cache = null;
+var _migrated = false;
+function readUserConfig() {
+  if (_cache !== null)
+    return _cache;
+  const path = _configPath();
+  if (!existsSync10(path)) {
+    _cache = {};
+    return _cache;
+  }
+  try {
+    const raw = readFileSync8(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    _cache = isPlainObject(parsed) ? parsed : {};
+  } catch {
+    _cache = {};
+  }
+  return _cache;
+}
+function writeUserConfig(patch) {
+  const current = readUserConfig();
+  const merged = deepMerge(current, patch);
+  const path = _configPath();
+  const dir = dirname2(path);
+  if (!existsSync10(dir))
+    mkdirSync2(dir, { recursive: true });
+  const tmp = `${path}.tmp.${process.pid}`;
+  writeFileSync6(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  renameSync2(tmp, path);
+  _cache = merged;
+  return merged;
+}
+function getEmbeddingsEnabled() {
+  const cfg = readUserConfig();
+  if (cfg.embeddings && typeof cfg.embeddings.enabled === "boolean") {
+    return cfg.embeddings.enabled;
+  }
+  if (_migrated) {
+    return migrationValueFromEnv();
+  }
+  _migrated = true;
+  const enabled = migrationValueFromEnv();
+  try {
+    writeUserConfig({ embeddings: { enabled } });
+  } catch {
+    _cache = { ...cfg ?? {}, embeddings: { ...cfg?.embeddings ?? {}, enabled } };
+  }
+  return enabled;
+}
+function migrationValueFromEnv() {
+  const raw = process.env.HIVEMIND_EMBEDDINGS;
+  if (raw === void 0)
+    return false;
+  if (raw === "false")
+    return false;
+  return true;
+}
+function setEmbeddingsEnabled(enabled) {
+  writeUserConfig({ embeddings: { enabled } });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const key of Object.keys(patch)) {
+    const patchVal = patch[key];
+    const baseVal = base[key];
+    if (isPlainObject(patchVal) && isPlainObject(baseVal)) {
+      out[key] = { ...baseVal, ...patchVal };
+    } else if (patchVal !== void 0) {
+      out[key] = patchVal;
+    }
+  }
+  return out;
+}
+
+// dist/src/cli/embeddings.js
+var SHARED_DIR = join12(HOME, ".hivemind", "embed-deps");
+var SHARED_NODE_MODULES = join12(SHARED_DIR, "node_modules");
+var SHARED_DAEMON_PATH = join12(SHARED_DIR, "embed-daemon.js");
 var TRANSFORMERS_PKG = "@huggingface/transformers";
 var TRANSFORMERS_RANGE = "^3.0.0";
 function findHivemindInstalls(home = HOME) {
   const out = [];
   const fixed = [
-    { id: "codex", pluginDir: join11(home, ".codex", "hivemind") },
-    { id: "cursor", pluginDir: join11(home, ".cursor", "hivemind") },
-    { id: "hermes", pluginDir: join11(home, ".hermes", "hivemind") }
+    { id: "codex", pluginDir: join12(home, ".codex", "hivemind") },
+    { id: "cursor", pluginDir: join12(home, ".cursor", "hivemind") },
+    { id: "hermes", pluginDir: join12(home, ".hermes", "hivemind") }
   ];
   for (const inst of fixed) {
-    if (existsSync10(join11(inst.pluginDir, "bundle")))
+    if (existsSync11(join12(inst.pluginDir, "bundle")))
       out.push(inst);
   }
-  const ccCache = join11(home, ".claude", "plugins", "cache", "hivemind", "hivemind");
-  if (existsSync10(ccCache)) {
+  const ccCache = join12(home, ".claude", "plugins", "cache", "hivemind", "hivemind");
+  if (existsSync11(ccCache)) {
     let entries = [];
     try {
       entries = readdirSync(ccCache);
     } catch {
     }
     for (const ver of entries) {
-      const dir = join11(ccCache, ver);
+      const dir = join12(ccCache, ver);
       try {
         if (!statSync(dir).isDirectory())
           continue;
       } catch {
         continue;
       }
-      const candidates = [join11(dir, "bundle"), join11(dir, "claude-code", "bundle")];
-      if (candidates.some((p) => existsSync10(p))) {
+      const candidates = [join12(dir, "bundle"), join12(dir, "claude-code", "bundle")];
+      if (candidates.some((p) => existsSync11(p))) {
         out.push({ id: `claude (${ver})`, pluginDir: dir });
       }
     }
@@ -3724,10 +3819,10 @@ function findHivemindInstalls(home = HOME) {
   return out;
 }
 function isSharedDepsInstalled(sharedNodeModules = SHARED_NODE_MODULES) {
-  return existsSync10(join11(sharedNodeModules, TRANSFORMERS_PKG));
+  return existsSync11(join12(sharedNodeModules, TRANSFORMERS_PKG));
 }
 function isSymlinkToSharedDeps(linkPath, sharedNodeModules) {
-  if (!existsSync10(linkPath))
+  if (!existsSync11(linkPath))
     return false;
   try {
     if (!lstatSync2(linkPath).isSymbolicLink())
@@ -3738,8 +3833,8 @@ function isSymlinkToSharedDeps(linkPath, sharedNodeModules) {
   }
 }
 function linkStateFor(install, sharedNodeModules = SHARED_NODE_MODULES) {
-  const link = join11(install.pluginDir, "node_modules");
-  if (!existsSync10(link) && !isSymbolicLink(link))
+  const link = join12(install.pluginDir, "node_modules");
+  if (!existsSync11(link) && !isSymbolicLink(link))
     return { kind: "no-node-modules" };
   try {
     if (lstatSync2(link).isSymbolicLink()) {
@@ -3763,7 +3858,7 @@ function ensureSharedDeps() {
     log(`  Embeddings     installing ${TRANSFORMERS_PKG}@${TRANSFORMERS_RANGE} into ${SHARED_DIR}`);
     log(`                 (~600 MB; first install only \u2014 every agent will share this)`);
     ensureDir(SHARED_DIR);
-    writeJson(join11(SHARED_DIR, "package.json"), {
+    writeJson(join12(SHARED_DIR, "package.json"), {
       name: "hivemind-embed-deps",
       version: "1.0.0",
       private: true,
@@ -3777,8 +3872,8 @@ function ensureSharedDeps() {
     log(`  Embeddings     shared deps already present at ${SHARED_DIR}`);
   }
   ensureDir(SHARED_DIR);
-  const src = join11(pkgRoot(), "embeddings", "embed-daemon.js");
-  if (existsSync10(src)) {
+  const src = join12(pkgRoot(), "embeddings", "embed-daemon.js");
+  if (existsSync11(src)) {
     copyFileSync3(src, SHARED_DAEMON_PATH);
     chmodSync(SHARED_DAEMON_PATH, 493);
   } else {
@@ -3786,40 +3881,115 @@ function ensureSharedDeps() {
   }
 }
 function linkAgent(install) {
-  const link = join11(install.pluginDir, "node_modules");
+  const link = join12(install.pluginDir, "node_modules");
+  const state = linkStateFor(install);
+  if (state.kind === "owns-own-node-modules") {
+    warn(`  Embeddings     ${install.id.padEnd(20)} owns its own node_modules \u2014 skipping symlink (status: owns-own-node-modules)`);
+    return;
+  }
   symlinkForce(SHARED_NODE_MODULES, link);
   log(`  Embeddings     linked ${install.id.padEnd(20)} -> shared deps`);
 }
-function enableEmbeddings() {
+function installEmbeddings() {
   ensureSharedDeps();
   const installs = findHivemindInstalls();
   if (installs.length === 0) {
     warn("  Embeddings     no hivemind installs detected \u2014 run `hivemind install` first");
     warn("                 (the shared deps are in place; subsequent agent installs will pick them up if you re-run `hivemind embeddings install`)");
-    return;
+  } else {
+    for (const inst of installs)
+      linkAgent(inst);
+  }
+  setEmbeddingsEnabled(true);
+  log(`  Embeddings     enabled in ~/.deeplake/config.json`);
+  log(`  Embeddings     ready. Restart your agents to pick up.`);
+}
+function enableEmbeddings() {
+  setEmbeddingsEnabled(true);
+  log(`  Embeddings     enabled in ~/.deeplake/config.json`);
+  if (!isSharedDepsInstalled()) {
+    warn(`  Embeddings     shared deps not installed yet \u2014 run \`hivemind embeddings install\` to download them`);
+  } else {
+    log(`  Embeddings     shared deps present \u2014 sessions will start producing embeddings on next restart`);
   }
-  for (const inst of installs)
-    linkAgent(inst);
-  log(`  Embeddings     enabled. Restart your agents to pick up.`);
 }
-function disableEmbeddings(opts) {
+function uninstallEmbeddings(opts) {
   const installs = findHivemindInstalls();
   for (const inst of installs) {
-    const link = join11(inst.pluginDir, "node_modules");
+    const link = join12(inst.pluginDir, "node_modules");
     if (isSymlinkToSharedDeps(link, SHARED_NODE_MODULES)) {
       unlinkSync5(link);
       log(`  Embeddings     unlinked ${inst.id}`);
     }
   }
-  if (opts?.prune && existsSync10(SHARED_DIR)) {
+  if (opts?.prune && existsSync11(SHARED_DIR)) {
     rmSync4(SHARED_DIR, { recursive: true, force: true });
     log(`  Embeddings     pruned ${SHARED_DIR}`);
   }
+  setEmbeddingsEnabled(false);
+  killEmbedDaemon();
+  log(`  Embeddings     disabled in ~/.deeplake/config.json`);
+}
+function disableEmbeddings() {
+  setEmbeddingsEnabled(false);
+  killEmbedDaemon();
+  log(`  Embeddings     disabled in ~/.deeplake/config.json`);
+  log(`  Embeddings     daemon terminated; shared deps preserved (run \`hivemind embeddings uninstall\` to remove)`);
+}
+function killEmbedDaemon(socketDir) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : userInfo().uid;
+  const pidPath = pidPathFor(String(uid), socketDir);
+  const sockPath = socketPathFor(String(uid), socketDir);
+  let pid = null;
+  try {
+    pid = Number.parseInt(readFileSync9(pidPath, "utf-8").trim(), 10);
+  } catch {
+  }
+  if (pid !== null && Number.isFinite(pid) && _isDaemonAliveOnSocket(sockPath)) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  } else if (pid !== null) {
+    log(`  Embeddings     pidfile present but socket dead \u2014 skipping SIGTERM on possibly-stale pid ${pid}`);
+  }
+  try {
+    unlinkSync5(sockPath);
+  } catch {
+  }
+  try {
+    unlinkSync5(pidPath);
+  } catch {
+  }
+}
+function _isDaemonAliveOnSocket(sockPath, timeoutMs = 200) {
+  if (!existsSync11(sockPath))
+    return false;
+  try {
+    const child = spawnSync("node", [
+      "-e",
+      `const n=require("node:net");const s=n.connect(${JSON.stringify(sockPath)});s.once("connect",()=>{s.end();process.exit(0)});s.once("error",()=>process.exit(2));setTimeout(()=>process.exit(3),${timeoutMs});`
+    ], { timeout: timeoutMs + 1e3, stdio: "ignore" });
+    return child.status === 0;
+  } catch {
+    return false;
+  }
 }
 function statusEmbeddings() {
+  const enabled = getEmbeddingsEnabled();
+  log(`Config:        ~/.deeplake/config.json embeddings.enabled = ${enabled}`);
   log(`Shared deps:   ${SHARED_DIR}`);
   log(`Installed:     ${isSharedDepsInstalled() ? "yes" : "no"}`);
-  log(`Daemon:        ${existsSync10(SHARED_DAEMON_PATH) ? SHARED_DAEMON_PATH : "(not present)"}`);
+  log(`Daemon:        ${existsSync11(SHARED_DAEMON_PATH) ? SHARED_DAEMON_PATH : "(not present)"}`);
+  if (!enabled) {
+    log("");
+    log(`Embeddings are DISABLED in user config. Run \`hivemind embeddings enable\` to opt in,`);
+    log(`or \`hivemind embeddings install\` if the shared deps are not yet downloaded.`);
+  } else if (!isSharedDepsInstalled()) {
+    log("");
+    warn(`Embeddings are enabled in config but shared deps are missing.`);
+    warn(`Run \`hivemind embeddings install\` to download @huggingface/transformers.`);
+  }
   log("");
   log(`Agent installs:`);
   const installs = findHivemindInstalls();
@@ -3835,7 +4005,7 @@ function statusEmbeddings() {
         label = "\u2713 linked \u2192 shared";
         break;
       case "no-node-modules":
-        label = "\u2717 not linked (embeddings disabled)";
+        label = "\u2717 not linked";
         break;
       case "owns-own-node-modules":
         label = "\u25B3 has its own node_modules (not shared)";
@@ -3850,8 +4020,8 @@ function statusEmbeddings() {
 }
 
 // dist/src/cli/auth.js
-import { existsSync as existsSync11 } from "node:fs";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // dist/src/commands/auth.js
 import { execSync } from "node:child_process";
@@ -3866,25 +4036,25 @@ function deeplakeClientHeader() {
 }
 
 // dist/src/commands/auth-creds.js
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync2, unlinkSync as unlinkSync6 } from "node:fs";
-import { join as join12 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync3, unlinkSync as unlinkSync6 } from "node:fs";
+import { join as join13 } from "node:path";
+import { homedir as homedir5 } from "node:os";
 function configDir() {
-  return join12(homedir4(), ".deeplake");
+  return join13(homedir5(), ".deeplake");
 }
 function credsPath() {
-  return join12(configDir(), "credentials.json");
+  return join13(configDir(), "credentials.json");
 }
 function loadCredentials() {
   try {
-    return JSON.parse(readFileSync8(credsPath(), "utf-8"));
+    return JSON.parse(readFileSync10(credsPath(), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveCredentials(creds) {
-  mkdirSync2(configDir(), { recursive: true, mode: 448 });
-  writeFileSync6(credsPath(), JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
+  mkdirSync3(configDir(), { recursive: true, mode: 448 });
+  writeFileSync7(credsPath(), JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
 }
 function deleteCredentials() {
   try {
@@ -4073,9 +4243,9 @@ Using: ${orgName}
 }
 
 // dist/src/cli/auth.js
-var CREDS_PATH = join13(HOME, ".deeplake", "credentials.json");
+var CREDS_PATH = join14(HOME, ".deeplake", "credentials.json");
 function isLoggedIn() {
-  return existsSync11(CREDS_PATH) && loadCredentials() !== null;
+  return existsSync12(CREDS_PATH) && loadCredentials() !== null;
 }
 async function ensureLoggedIn() {
   if (isLoggedIn())
@@ -4108,16 +4278,16 @@ async function maybeShowOrgChoice() {
 }
 
 // dist/src/config.js
-import { readFileSync as readFileSync9, existsSync as existsSync12 } from "node:fs";
-import { join as join14 } from "node:path";
-import { homedir as homedir5, userInfo } from "node:os";
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "node:fs";
+import { join as join15 } from "node:path";
+import { homedir as homedir6, userInfo as userInfo2 } from "node:os";
 function loadConfig() {
-  const home = homedir5();
-  const credPath = join14(home, ".deeplake", "credentials.json");
+  const home = homedir6();
+  const credPath = join15(home, ".deeplake", "credentials.json");
   let creds = null;
-  if (existsSync12(credPath)) {
+  if (existsSync13(credPath)) {
     try {
-      creds = JSON.parse(readFileSync9(credPath, "utf-8"));
+      creds = JSON.parse(readFileSync11(credPath, "utf-8"));
     } catch {
       return null;
     }
@@ -4130,13 +4300,13 @@ function loadConfig() {
     token,
     orgId,
     orgName: creds?.orgName ?? orgId,
-    userName: creds?.userName || userInfo().username || "unknown",
+    userName: creds?.userName || userInfo2().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",
-    memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join14(home, ".deeplake", "memory")
+    memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join15(home, ".deeplake", "memory")
   };
 }
 
@@ -4145,9 +4315,9 @@ import { randomUUID } from "node:crypto";
 
 // dist/src/utils/debug.js
 import { appendFileSync } from "node:fs";
-import { join as join15 } from "node:path";
-import { homedir as homedir6 } from "node:os";
-var LOG = join15(homedir6(), ".deeplake", "hook-debug.log");
+import { join as join16 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+var LOG = join16(homedir7(), ".deeplake", "hook-debug.log");
 function isDebug() {
   return process.env.HIVEMIND_DEBUG === "1";
 }
@@ -4173,6 +4343,107 @@ function sqlIdent(name) {
 var SUMMARY_EMBEDDING_COL = "summary_embedding";
 var MESSAGE_EMBEDDING_COL = "message_embedding";
 
+// dist/src/notifications/queue.js
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, renameSync as renameSync3, mkdirSync as mkdirSync4, openSync, closeSync, unlinkSync as unlinkSync7, statSync as statSync2 } from "node:fs";
+import { join as join17, resolve } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { setTimeout as sleep } from "node:timers/promises";
+var log3 = (msg) => log2("notifications-queue", msg);
+var LOCK_RETRY_MAX = 50;
+var LOCK_RETRY_BASE_MS = 5;
+var LOCK_STALE_MS = 5e3;
+function queuePath() {
+  return join17(homedir8(), ".deeplake", "notifications-queue.json");
+}
+function lockPath() {
+  return `${queuePath()}.lock`;
+}
+function readQueue() {
+  try {
+    const raw = readFileSync12(queuePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.queue)) {
+      log3(`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(homedir8());
+  if (!_isQueuePathInsideHome(path, home)) {
+    throw new Error(`notifications-queue write blocked: ${path} is outside ${home}`);
+  }
+  mkdirSync4(join17(home, ".deeplake"), { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync8(tmp, JSON.stringify(q, null, 2), { mode: 384 });
+  renameSync3(tmp, path);
+}
+async function withQueueLock(fn) {
+  const path = lockPath();
+  mkdirSync4(join17(homedir8(), ".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() - statSync2(path).mtimeMs;
+        if (age > LOCK_STALE_MS) {
+          unlinkSync7(path);
+          continue;
+        }
+      } catch {
+      }
+      const delay = LOCK_RETRY_BASE_MS * (attempt + 1);
+      await sleep(delay);
+    }
+  }
+  if (fd === null) {
+    log3(`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 {
+      unlinkSync7(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/deeplake-api.js
 var indexMarkerStorePromise = null;
 function getIndexMarkerStore() {
@@ -4180,7 +4451,7 @@ function getIndexMarkerStore() {
     indexMarkerStorePromise = Promise.resolve().then(() => (init_index_marker_store(), index_marker_store_exports));
   return indexMarkerStorePromise;
 }
-var log3 = (msg) => log2("sdk", msg);
+var log4 = (msg) => log2("sdk", msg);
 function summarizeSql(sql, maxLen = 220) {
   const compact = sql.replace(/\s+/g, " ").trim();
   return compact.length > maxLen ? `${compact.slice(0, maxLen)}...` : compact;
@@ -4192,7 +4463,38 @@ function traceSql(msg) {
   process.stderr.write(`[deeplake-sql] ${msg}
 `);
   if (process.env.HIVEMIND_DEBUG === "1")
-    log3(msg);
+    log4(msg);
+}
+var _signalledBalanceExhausted = false;
+function maybeSignalBalanceExhausted(status, bodyText) {
+  if (status !== 402)
+    return;
+  if (!bodyText.includes("balance_cents"))
+    return;
+  if (_signalledBalanceExhausted)
+    return;
+  _signalledBalanceExhausted = true;
+  log4(`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" }
+  }).catch((e) => {
+    log4(`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;
@@ -4201,8 +4503,8 @@ var MAX_CONCURRENCY = 5;
 function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -4232,7 +4534,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve) => this.waiting.push(resolve));
+    await new Promise((resolve2) => this.waiting.push(resolve2));
   }
   release() {
     this.active--;
@@ -4303,8 +4605,8 @@ var DeeplakeApi = class {
         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 sleep(delay);
+          log4(`query retry ${attempt + 1}/${MAX_RETRIES} (fetch error: ${lastError.message}) in ${delay.toFixed(0)}ms`);
+          await sleep2(delay);
           continue;
         }
         throw lastError;
@@ -4320,10 +4622,11 @@ var DeeplakeApi = class {
       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 sleep(delay);
+        log4(`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");
@@ -4344,7 +4647,7 @@ var DeeplakeApi = class {
       const chunk = rows.slice(i, i + CONCURRENCY);
       await Promise.allSettled(chunk.map((r) => this.upsertRowSql(r)));
     }
-    log3(`commit: ${rows.length} rows`);
+    log4(`commit: ${rows.length} rows`);
   }
   async upsertRowSql(row) {
     const ts = (/* @__PURE__ */ new Date()).toISOString();
@@ -4400,7 +4703,7 @@ var DeeplakeApi = class {
         markers.writeIndexMarker(markerPath);
         return;
       }
-      log3(`index "${indexName}" skipped: ${e.message}`);
+      log4(`index "${indexName}" skipped: ${e.message}`);
     }
   }
   /**
@@ -4490,13 +4793,13 @@ var DeeplakeApi = class {
           };
         }
         if (attempt < MAX_RETRIES && RETRYABLE_CODES.has(resp.status)) {
-          await sleep(BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 200);
+          await sleep2(BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 200);
           continue;
         }
         return { tables: [], cacheable: false };
       } catch {
         if (attempt < MAX_RETRIES) {
-          await sleep(BASE_DELAY_MS * Math.pow(2, attempt));
+          await sleep2(BASE_DELAY_MS * Math.pow(2, attempt));
           continue;
         }
         return { tables: [], cacheable: false };
@@ -4524,9 +4827,9 @@ var DeeplakeApi = class {
       } 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}`);
+        log4(`CREATE TABLE "${label}" attempt ${attempt + 1}/${OUTER_BACKOFFS_MS.length + 1} failed: ${msg}`);
         if (attempt < OUTER_BACKOFFS_MS.length) {
-          await sleep(OUTER_BACKOFFS_MS[attempt]);
+          await sleep2(OUTER_BACKOFFS_MS[attempt]);
         }
       }
     }
@@ -4537,9 +4840,9 @@ var DeeplakeApi = class {
     const tbl = sqlIdent(name ?? this.tableName);
     const tables = await this.listTables();
     if (!tables.includes(tbl)) {
-      log3(`table "${tbl}" not found, creating`);
+      log4(`table "${tbl}" not found, creating`);
       await this.createTableWithRetry(`CREATE TABLE IF NOT EXISTS "${tbl}" (id TEXT NOT NULL DEFAULT '', path TEXT NOT NULL DEFAULT '', filename TEXT NOT NULL DEFAULT '', summary TEXT NOT NULL DEFAULT '', summary_embedding FLOAT4[], author TEXT NOT NULL DEFAULT '', mime_type TEXT NOT NULL DEFAULT 'text/plain', size_bytes BIGINT NOT NULL DEFAULT 0, project TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '', agent TEXT NOT NULL DEFAULT '', plugin_version TEXT NOT NULL DEFAULT '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`, tbl);
-      log3(`table "${tbl}" created`);
+      log4(`table "${tbl}" created`);
       if (!tables.includes(tbl))
         this._tablesCache = [...tables, tbl];
     }
@@ -4552,9 +4855,9 @@ var DeeplakeApi = class {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
     if (!tables.includes(safe)) {
-      log3(`table "${safe}" not found, creating`);
+      log4(`table "${safe}" not found, creating`);
       await this.createTableWithRetry(`CREATE TABLE IF NOT EXISTS "${safe}" (id TEXT NOT NULL DEFAULT '', path TEXT NOT NULL DEFAULT '', filename TEXT NOT NULL DEFAULT '', message JSONB, message_embedding FLOAT4[], author TEXT NOT NULL DEFAULT '', mime_type TEXT NOT NULL DEFAULT 'application/json', size_bytes BIGINT NOT NULL DEFAULT 0, project TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '', agent TEXT NOT NULL DEFAULT '', plugin_version TEXT NOT NULL DEFAULT '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`, safe);
-      log3(`table "${safe}" created`);
+      log4(`table "${safe}" created`);
       if (!tables.includes(safe))
         this._tablesCache = [...tables, safe];
     }
@@ -4577,9 +4880,9 @@ var DeeplakeApi = class {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
     if (!tables.includes(safe)) {
-      log3(`table "${safe}" not found, creating`);
+      log4(`table "${safe}" not found, creating`);
       await this.createTableWithRetry(`CREATE TABLE IF NOT EXISTS "${safe}" (id TEXT NOT NULL DEFAULT '', name TEXT NOT NULL DEFAULT '', project TEXT NOT NULL DEFAULT '', project_key TEXT NOT NULL DEFAULT '', local_path TEXT NOT NULL DEFAULT '', install TEXT NOT NULL DEFAULT 'project', source_sessions TEXT NOT NULL DEFAULT '[]', source_agent TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT 'me', author TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '', trigger_text TEXT NOT NULL DEFAULT '', body TEXT NOT NULL DEFAULT '', version BIGINT NOT NULL DEFAULT 1, created_at TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL DEFAULT '') USING deeplake`, safe);
-      log3(`table "${safe}" created`);
+      log4(`table "${safe}" created`);
       if (!tables.includes(safe))
         this._tablesCache = [...tables, safe];
     }
@@ -4610,10 +4913,10 @@ function parseArgs(argv) {
 }
 function confirm(message) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
+      resolve2(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -4915,34 +5218,34 @@ if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
 }
 
 // dist/src/commands/skillify.js
-import { readdirSync as readdirSync5, existsSync as existsSync25, readFileSync as readFileSync18, mkdirSync as mkdirSync10, renameSync as renameSync5 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { dirname as dirname6, join as join28 } from "node:path";
+import { readdirSync as readdirSync5, existsSync as existsSync26, readFileSync as readFileSync21, mkdirSync as mkdirSync12, renameSync as renameSync7 } from "node:fs";
+import { homedir as homedir20 } from "node:os";
+import { dirname as dirname7, join as join30 } from "node:path";
 
 // dist/src/skillify/scope-config.js
-import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join20 } from "node:path";
 
 // dist/src/skillify/legacy-migration.js
-import { existsSync as existsSync14, renameSync as renameSync2 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync15, renameSync as renameSync4 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join19 } from "node:path";
 var dlog = (msg) => log2("skillify-migrate", msg);
 var attempted = false;
 function migrateLegacyStateDir() {
   if (attempted)
     return;
   attempted = true;
-  const root = join17(homedir7(), ".deeplake", "state");
-  const legacy = join17(root, "skilify");
-  const current = join17(root, "skillify");
-  if (!existsSync14(legacy))
+  const root = join19(homedir9(), ".deeplake", "state");
+  const legacy = join19(root, "skilify");
+  const current = join19(root, "skillify");
+  if (!existsSync15(legacy))
     return;
-  if (existsSync14(current))
+  if (existsSync15(current))
     return;
   try {
-    renameSync2(legacy, current);
+    renameSync4(legacy, current);
     dlog(`migrated ${legacy} -> ${current}`);
   } catch (err) {
     const code = err.code;
@@ -4955,15 +5258,15 @@ function migrateLegacyStateDir() {
 }
 
 // dist/src/skillify/scope-config.js
-var STATE_DIR = join18(homedir8(), ".deeplake", "state", "skillify");
-var CONFIG_PATH2 = join18(STATE_DIR, "config.json");
+var STATE_DIR = join20(homedir10(), ".deeplake", "state", "skillify");
+var CONFIG_PATH2 = join20(STATE_DIR, "config.json");
 var DEFAULT = { scope: "me", team: [], install: "project" };
 function loadScopeConfig() {
   migrateLegacyStateDir();
-  if (!existsSync15(CONFIG_PATH2))
+  if (!existsSync16(CONFIG_PATH2))
     return DEFAULT;
   try {
-    const raw = JSON.parse(readFileSync11(CONFIG_PATH2, "utf-8"));
+    const raw = JSON.parse(readFileSync14(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";
@@ -4974,19 +5277,19 @@ function loadScopeConfig() {
 }
 function saveScopeConfig(cfg) {
   migrateLegacyStateDir();
-  mkdirSync4(STATE_DIR, { recursive: true });
-  writeFileSync8(CONFIG_PATH2, JSON.stringify(cfg, null, 2));
+  mkdirSync6(STATE_DIR, { recursive: true });
+  writeFileSync10(CONFIG_PATH2, JSON.stringify(cfg, null, 2));
 }
 
 // dist/src/skillify/pull.js
-import { existsSync as existsSync19, readFileSync as readFileSync14, writeFileSync as writeFileSync11, mkdirSync as mkdirSync7, renameSync as renameSync4, lstatSync as lstatSync4, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync8 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { dirname as dirname3, join as join22 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync17, writeFileSync as writeFileSync13, mkdirSync as mkdirSync9, renameSync as renameSync6, lstatSync as lstatSync4, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync9 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname4, join as join24 } from "node:path";
 
 // dist/src/skillify/skill-writer.js
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync9 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync15, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join21 } from "node:path";
 function assertValidSkillName(name) {
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`invalid skill name: empty or non-string`);
@@ -5002,10 +5305,10 @@ function assertValidSkillName(name) {
   }
 }
 function skillDir(skillsRoot, name) {
-  return join19(skillsRoot, name);
+  return join21(skillsRoot, name);
 }
 function skillPath(skillsRoot, name) {
-  return join19(skillDir(skillsRoot, name), "SKILL.md");
+  return join21(skillDir(skillsRoot, name), "SKILL.md");
 }
 function renderFrontmatter(fm) {
   const lines = ["---"];
@@ -5083,10 +5386,10 @@ function writeNewSkill(args) {
   assertValidSkillName(args.name);
   const dir = skillDir(args.skillsRoot, args.name);
   const path = skillPath(args.skillsRoot, args.name);
-  if (existsSync16(path)) {
+  if (existsSync17(path)) {
     throw new Error(`skill already exists at ${path}; use mergeSkill`);
   }
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync7(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] : [];
@@ -5106,7 +5409,7 @@ function writeNewSkill(args) {
 
 ${args.body.trim()}
 `;
-  writeFileSync9(path, text);
+  writeFileSync11(path, text);
   return {
     path,
     action: "created",
@@ -5118,41 +5421,41 @@ ${args.body.trim()}
   };
 }
 function listSkills(skillsRoot) {
-  if (!existsSync16(skillsRoot))
+  if (!existsSync17(skillsRoot))
     return [];
   const out = [];
   for (const name of readdirSync2(skillsRoot)) {
-    const skillFile = join19(skillsRoot, name, "SKILL.md");
-    if (existsSync16(skillFile) && statSync2(skillFile).isFile()) {
-      out.push({ name, body: readFileSync12(skillFile, "utf-8") });
+    const skillFile = join21(skillsRoot, name, "SKILL.md");
+    if (existsSync17(skillFile) && statSync3(skillFile).isFile()) {
+      out.push({ name, body: readFileSync15(skillFile, "utf-8") });
     }
   }
   return out;
 }
 function resolveSkillsRoot(install, cwd) {
   if (install === "global") {
-    return join19(homedir9(), ".claude", "skills");
+    return join21(homedir11(), ".claude", "skills");
   }
-  return join19(cwd, ".claude", "skills");
+  return join21(cwd, ".claude", "skills");
 }
 
 // dist/src/skillify/manifest.js
-import { existsSync as existsSync17, lstatSync as lstatSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync13, renameSync as renameSync3, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname2, join as join20 } from "node:path";
+import { existsSync as existsSync18, lstatSync as lstatSync3, mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync5, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { dirname as dirname3, join as join22 } from "node:path";
 function emptyManifest() {
   return { version: 1, entries: [] };
 }
 function manifestPath() {
-  return join20(homedir10(), ".deeplake", "state", "skillify", "pulled.json");
+  return join22(homedir12(), ".deeplake", "state", "skillify", "pulled.json");
 }
 function loadManifest(path = manifestPath()) {
   migrateLegacyStateDir();
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     return emptyManifest();
   let raw;
   try {
-    raw = readFileSync13(path, "utf-8");
+    raw = readFileSync16(path, "utf-8");
   } catch {
     return emptyManifest();
   }
@@ -5199,10 +5502,10 @@ function loadManifest(path = manifestPath()) {
 }
 function saveManifest(m, path = manifestPath()) {
   migrateLegacyStateDir();
-  mkdirSync6(dirname2(path), { recursive: true });
+  mkdirSync8(dirname3(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  writeFileSync10(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
-  renameSync3(tmp, path);
+  writeFileSync12(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  renameSync5(tmp, path);
 }
 function recordPull(entry, path = manifestPath()) {
   const m = loadManifest(path);
@@ -5234,7 +5537,7 @@ function unlinkSymlinks(paths) {
     if (!st.isSymbolicLink())
       continue;
     try {
-      unlinkSync7(path);
+      unlinkSync8(path);
     } catch {
     }
   }
@@ -5244,7 +5547,7 @@ function pruneOrphanedEntries(path = manifestPath()) {
   const live = [];
   let pruned = 0;
   for (const e of m.entries) {
-    if (existsSync17(join20(e.installRoot, e.dirName))) {
+    if (existsSync18(join22(e.installRoot, e.dirName))) {
       live.push(e);
       continue;
     }
@@ -5257,26 +5560,26 @@ function pruneOrphanedEntries(path = manifestPath()) {
 }
 
 // dist/src/skillify/agent-roots.js
-import { existsSync as existsSync18 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { join as join23 } from "node:path";
 function resolveDetected(home) {
   const out = [];
-  const codexInstalled = existsSync18(join21(home, ".codex"));
-  const piInstalled = existsSync18(join21(home, ".pi", "agent"));
-  const hermesInstalled = existsSync18(join21(home, ".hermes"));
+  const codexInstalled = existsSync19(join23(home, ".codex"));
+  const piInstalled = existsSync19(join23(home, ".pi", "agent"));
+  const hermesInstalled = existsSync19(join23(home, ".hermes"));
   if (codexInstalled || piInstalled) {
-    out.push(join21(home, ".agents", "skills"));
+    out.push(join23(home, ".agents", "skills"));
   }
   if (hermesInstalled) {
-    out.push(join21(home, ".hermes", "skills"));
+    out.push(join23(home, ".hermes", "skills"));
   }
   if (piInstalled) {
-    out.push(join21(home, ".pi", "agent", "skills"));
+    out.push(join23(home, ".pi", "agent", "skills"));
   }
   return out;
 }
-function detectAgentSkillsRoots(canonicalRoot, home = homedir11()) {
+function detectAgentSkillsRoots(canonicalRoot, home = homedir13()) {
   return resolveDetected(home).filter((p) => p !== canonicalRoot);
 }
 
@@ -5320,15 +5623,15 @@ function isMissingTableError(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join22(homedir12(), ".claude", "skills");
+    return join24(homedir14(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join22(cwd, ".claude", "skills");
+  return join24(cwd, ".claude", "skills");
 }
 function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
   const out = [];
   for (const root of agentRoots) {
-    const link = join22(root, dirName);
+    const link = join24(root, dirName);
     let existing;
     try {
       existing = lstatSync4(link);
@@ -5350,13 +5653,13 @@ function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
         continue;
       }
       try {
-        unlinkSync8(link);
+        unlinkSync9(link);
       } catch {
         continue;
       }
     }
     try {
-      mkdirSync7(dirname3(link), { recursive: true });
+      mkdirSync9(dirname4(link), { recursive: true });
       symlinkSync2(canonicalDir, link, "dir");
       out.push(link);
     } catch {
@@ -5371,8 +5674,8 @@ function backfillSymlinks(installRoot) {
     return;
   const detected = detectAgentSkillsRoots(installRoot);
   for (const entry of entries) {
-    const canonical = join22(entry.installRoot, entry.dirName);
-    if (!existsSync19(canonical))
+    const canonical = join24(entry.installRoot, entry.dirName);
+    if (!existsSync20(canonical))
       continue;
     const fresh = fanOutSymlinks(canonical, entry.dirName, detected);
     if (sameSorted(fresh, entry.symlinks))
@@ -5482,10 +5785,10 @@ function renderFrontmatter2(fm) {
   return lines.join("\n");
 }
 function readLocalVersion(path) {
-  if (!existsSync19(path))
+  if (!existsSync20(path))
     return null;
   try {
-    const text = readFileSync14(path, "utf-8");
+    const text = readFileSync17(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -5580,8 +5883,8 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const skillDir2 = join22(root, dirName);
-    const skillFile = join22(skillDir2, "SKILL.md");
+    const skillDir2 = join24(root, dirName);
+    const skillFile = join24(skillDir2, "SKILL.md");
     const remoteVersion = Number(row.version ?? 1);
     const localVersion = readLocalVersion(skillFile);
     const action = decideAction({
@@ -5592,14 +5895,14 @@ async function runPull(opts) {
     });
     let manifestError;
     if (action === "wrote") {
-      mkdirSync7(skillDir2, { recursive: true });
-      if (existsSync19(skillFile)) {
+      mkdirSync9(skillDir2, { recursive: true });
+      if (existsSync20(skillFile)) {
         try {
-          renameSync4(skillFile, `${skillFile}.bak`);
+          renameSync6(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync11(skillFile, renderSkillFile(row));
+      writeFileSync13(skillFile, renderSkillFile(row));
       const symlinks = opts.install === "global" ? fanOutSymlinks(skillDir2, dirName, detectAgentSkillsRoots(root)) : [];
       try {
         recordPull({
@@ -5641,15 +5944,15 @@ async function runPull(opts) {
 }
 
 // dist/src/skillify/unpull.js
-import { existsSync as existsSync20, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync3 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync21, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync4 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join25 } from "node:path";
 function resolveUnpullRoot(install, cwd) {
   if (install === "global")
-    return join23(homedir13(), ".claude", "skills");
+    return join25(homedir15(), ".claude", "skills");
   if (!cwd)
     throw new Error("cwd required when install === 'project'");
-  return join23(cwd, ".claude", "skills");
+  return join25(cwd, ".claude", "skills");
 }
 function runUnpull(opts) {
   const root = resolveUnpullRoot(opts.install, opts.cwd);
@@ -5672,8 +5975,8 @@ function runUnpull(opts) {
   const entries = entriesForRoot(manifest, opts.install, root);
   for (const entry of entries) {
     summary.scanned++;
-    const path = join23(root, entry.dirName);
-    if (!existsSync20(path)) {
+    const path = join25(root, entry.dirName);
+    if (!existsSync21(path)) {
       if (!opts.dryRun) {
         unlinkSymlinks(entry.symlinks);
         removePullEntry(opts.install, entry.installRoot, entry.dirName);
@@ -5726,15 +6029,15 @@ function runUnpull(opts) {
     }
     summary.entries.push(result);
   }
-  if (existsSync20(root) && (opts.all || opts.legacyCleanup)) {
+  if (existsSync21(root) && (opts.all || opts.legacyCleanup)) {
     const manifestDirNames = new Set(entries.map((e) => e.dirName));
     for (const dirName of readdirSync3(root)) {
       if (manifestDirNames.has(dirName))
         continue;
-      const path = join23(root, dirName);
+      const path = join25(root, dirName);
       let st;
       try {
-        st = statSync3(path);
+        st = statSync4(path);
       } catch {
         continue;
       }
@@ -5810,30 +6113,30 @@ function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
 
 // dist/src/commands/mine-local.js
 import { spawn } from "node:child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { basename, dirname as dirname5, join as join27 } from "node:path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import { basename, dirname as dirname6, join as join29 } from "node:path";
 
 // dist/src/skillify/local-source.js
-import { readdirSync as readdirSync4, readFileSync as readFileSync15, existsSync as existsSync21, statSync as statSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join24 } from "node:path";
-var HOME2 = homedir14();
+import { readdirSync as readdirSync4, readFileSync as readFileSync18, existsSync as existsSync22, statSync as statSync5 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { join as join26 } from "node:path";
+var HOME2 = homedir16();
 function encodeCwdClaudeCode(cwd) {
   return cwd.replace(/[/_]/g, "-");
 }
 function detectInstalledAgents() {
   const installs = [];
-  const claudeRoot = join24(HOME2, ".claude", "projects");
-  if (existsSync21(claudeRoot)) {
+  const claudeRoot = join26(HOME2, ".claude", "projects");
+  if (existsSync22(claudeRoot)) {
     installs.push({
       agent: "claude_code",
       sessionRoot: claudeRoot,
       encodeCwd: encodeCwdClaudeCode
     });
   }
-  const codexRoot = join24(HOME2, ".codex", "sessions");
-  if (existsSync21(codexRoot)) {
+  const codexRoot = join26(HOME2, ".codex", "sessions");
+  if (existsSync22(codexRoot)) {
     installs.push({
       agent: "codex",
       sessionRoot: codexRoot,
@@ -5860,9 +6163,9 @@ function listLocalSessions(installs, cwd) {
       continue;
     }
     for (const sub of subdirs) {
-      const subdirPath = join24(install.sessionRoot, sub);
+      const subdirPath = join26(install.sessionRoot, sub);
       try {
-        if (!statSync4(subdirPath).isDirectory())
+        if (!statSync5(subdirPath).isDirectory())
           continue;
       } catch {
         continue;
@@ -5877,10 +6180,10 @@ function listLocalSessions(installs, cwd) {
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const fullPath = join24(subdirPath, f);
+        const fullPath = join26(subdirPath, f);
         let stats;
         try {
-          stats = statSync4(fullPath);
+          stats = statSync5(fullPath);
         } catch {
           continue;
         }
@@ -5938,7 +6241,7 @@ function pickSessions(candidates, opts) {
 function nativeJsonlToRows(filePath, sessionId, agent) {
   let raw;
   try {
-    raw = readFileSync15(filePath, "utf-8");
+    raw = readFileSync18(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -6028,22 +6331,22 @@ function extractPairs(rows) {
 }
 
 // dist/src/skillify/gate-runner.js
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir15 } from "node:os";
-import { join as join25 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { join as join27 } from "node:path";
 var requireForCp = createRequire(import.meta.url);
 var { execFileSync: runChildProcess } = requireForCp("node:child_process");
 var inheritedEnv = process;
 function firstExistingPath(candidates) {
   for (const c of candidates) {
-    if (existsSync22(c))
+    if (existsSync23(c))
       return c;
   }
   return null;
 }
 function findAgentBin(agent) {
-  const home = homedir15();
+  const home = homedir17();
   switch (agent) {
     // /usr/bin/<name> is included in every candidate list — that's the
     // common Linux package-manager install path (apt, dnf, pacman). Old
@@ -6052,45 +6355,45 @@ function findAgentBin(agent) {
     // #170 caught the gap.
     case "claude_code":
       return firstExistingPath([
-        join25(home, ".claude", "local", "claude"),
+        join27(home, ".claude", "local", "claude"),
         "/usr/local/bin/claude",
         "/usr/bin/claude",
-        join25(home, ".npm-global", "bin", "claude"),
-        join25(home, ".local", "bin", "claude"),
+        join27(home, ".npm-global", "bin", "claude"),
+        join27(home, ".local", "bin", "claude"),
         "/opt/homebrew/bin/claude"
-      ]) ?? join25(home, ".claude", "local", "claude");
+      ]) ?? join27(home, ".claude", "local", "claude");
     case "codex":
       return firstExistingPath([
         "/usr/local/bin/codex",
         "/usr/bin/codex",
-        join25(home, ".npm-global", "bin", "codex"),
-        join25(home, ".local", "bin", "codex"),
+        join27(home, ".npm-global", "bin", "codex"),
+        join27(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",
-        join25(home, ".npm-global", "bin", "cursor-agent"),
-        join25(home, ".local", "bin", "cursor-agent"),
+        join27(home, ".npm-global", "bin", "cursor-agent"),
+        join27(home, ".local", "bin", "cursor-agent"),
         "/opt/homebrew/bin/cursor-agent"
       ]) ?? "/usr/local/bin/cursor-agent";
     case "hermes":
       return firstExistingPath([
-        join25(home, ".local", "bin", "hermes"),
+        join27(home, ".local", "bin", "hermes"),
         "/usr/local/bin/hermes",
         "/usr/bin/hermes",
-        join25(home, ".npm-global", "bin", "hermes"),
+        join27(home, ".npm-global", "bin", "hermes"),
         "/opt/homebrew/bin/hermes"
-      ]) ?? join25(home, ".local", "bin", "hermes");
+      ]) ?? join27(home, ".local", "bin", "hermes");
     case "pi":
       return firstExistingPath([
-        join25(home, ".local", "bin", "pi"),
+        join27(home, ".local", "bin", "pi"),
         "/usr/local/bin/pi",
         "/usr/bin/pi",
-        join25(home, ".npm-global", "bin", "pi"),
+        join27(home, ".npm-global", "bin", "pi"),
         "/opt/homebrew/bin/pi"
-      ]) ?? join25(home, ".local", "bin", "pi");
+      ]) ?? join27(home, ".local", "bin", "pi");
   }
 }
 
@@ -6120,27 +6423,27 @@ function extractJsonBlock(s) {
 }
 
 // dist/src/skillify/local-manifest.js
-import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { dirname as dirname4, join as join26 } from "node:path";
-var LOCAL_MANIFEST_PATH = join26(homedir16(), ".claude", "hivemind", "local-mined.json");
-var LOCAL_MINE_LOCK_PATH = join26(homedir16(), ".claude", "hivemind", "local-mined.lock");
+import { existsSync as existsSync24, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir18 } from "node:os";
+import { dirname as dirname5, join as join28 } from "node:path";
+var LOCAL_MANIFEST_PATH = join28(homedir18(), ".claude", "hivemind", "local-mined.json");
+var LOCAL_MINE_LOCK_PATH = join28(homedir18(), ".claude", "hivemind", "local-mined.lock");
 function readLocalManifest(path = LOCAL_MANIFEST_PATH) {
-  if (!existsSync23(path))
+  if (!existsSync24(path))
     return null;
   try {
-    return JSON.parse(readFileSync16(path, "utf-8"));
+    return JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLocalManifest(m, path = LOCAL_MANIFEST_PATH) {
-  mkdirSync8(dirname4(path), { recursive: true });
-  writeFileSync12(path, JSON.stringify(m, null, 2));
+  mkdirSync10(dirname5(path), { recursive: true });
+  writeFileSync14(path, JSON.stringify(m, null, 2));
 }
 
 // dist/src/commands/mine-local.js
-import { unlinkSync as unlinkSync9 } from "node:fs";
+import { unlinkSync as unlinkSync10 } from "node:fs";
 var EPSILON = 0.3;
 var DEFAULT_N = 8;
 var PAIR_CHAR_CAP = 4e3;
@@ -6151,9 +6454,9 @@ var IN_FLIGHT_MAX_AGE_MS = 6e4;
 var GATE_TIMEOUT_MS = 24e4;
 var MANIFEST_PATH = LOCAL_MANIFEST_PATH;
 function runGateViaStdin(opts) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (opts.agent !== "claude_code") {
-      resolve({
+      resolve2({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6161,8 +6464,8 @@ function runGateViaStdin(opts) {
       });
       return;
     }
-    if (!existsSync24(opts.bin)) {
-      resolve({
+    if (!existsSync25(opts.bin)) {
+      resolve2({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6189,7 +6492,7 @@ function runGateViaStdin(opts) {
       if (settled)
         return;
       settled = true;
-      resolve(r);
+      resolve2(r);
     };
     const timer = setTimeout(() => {
       try {
@@ -6449,7 +6752,7 @@ async function runMineLocal(args) {
       return;
     lockReleased = true;
     try {
-      unlinkSync9(LOCAL_MINE_LOCK_PATH);
+      unlinkSync10(LOCAL_MINE_LOCK_PATH);
     } catch {
     }
   };
@@ -6506,8 +6809,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 = join27(homedir17(), ".claude", "hivemind", `mine-local-${Date.now()}`);
-  mkdirSync9(tmpDir, { recursive: true });
+  const tmpDir = join29(homedir19(), ".claude", "hivemind", `mine-local-${Date.now()}`);
+  mkdirSync11(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);
@@ -6518,23 +6821,23 @@ async function runMineLocalImpl(args) {
       return { session: s, skills: [], reason: "no pairs", error: null };
     }
     const tail = pairs2.slice(-PER_SESSION_PAIR_CAP);
-    const sessionTmp = join27(tmpDir, `s-${shortId}`);
-    mkdirSync9(sessionTmp, { recursive: true });
-    const verdictPath = join27(sessionTmp, "verdict.json");
+    const sessionTmp = join29(tmpDir, `s-${shortId}`);
+    mkdirSync11(sessionTmp, { recursive: true });
+    const verdictPath = join29(sessionTmp, "verdict.json");
     const prompt = buildSessionPrompt(tail, s, verdictPath);
-    writeFileSync13(join27(sessionTmp, "prompt.txt"), prompt);
+    writeFileSync15(join29(sessionTmp, "prompt.txt"), prompt);
     const gate = await runGateViaStdin({ agent: gateAgent, bin: gateBin, prompt, timeoutMs: GATE_TIMEOUT_MS });
     try {
-      writeFileSync13(join27(sessionTmp, "gate-stdout.txt"), gate.stdout);
+      writeFileSync15(join29(sessionTmp, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync13(join27(sessionTmp, "gate-stderr.txt"), gate.stderr);
+        writeFileSync15(join29(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 = existsSync24(verdictPath) ? readFileSync17(verdictPath, "utf-8") : gate.stdout;
+    const verdictText = existsSync25(verdictPath) ? readFileSync20(verdictPath, "utf-8") : gate.stdout;
     const mv = parseMultiVerdict(verdictText);
     if (!mv) {
       console.log(`  [${shortId}] unparseable verdict (kept at ${sessionTmp})`);
@@ -6586,7 +6889,7 @@ async function runMineLocalImpl(args) {
         sourceSessions: [session.sessionId],
         agent: gateAgent
       });
-      const canonicalDir = dirname5(result.path);
+      const canonicalDir = dirname6(result.path);
       const symlinks = fanOutRoots.length > 0 ? fanOutSymlinks(canonicalDir, basename(canonicalDir), fanOutRoots) : [];
       const symlinkSuffix = symlinks.length > 0 ? `, fan-out \u2192 ${symlinks.length} root(s)` : "";
       console.log(`  wrote ${skill.name} \u2190 session ${session.sessionId.slice(0, 8)} (${session.agent}${symlinkSuffix})`);
@@ -6750,7 +7053,7 @@ function wrapAt(s, max) {
 
 // dist/src/commands/skillify.js
 function stateDir() {
-  return join28(homedir18(), ".deeplake", "state", "skillify");
+  return join30(homedir20(), ".deeplake", "state", "skillify");
 }
 function showStatus() {
   const cfg = loadScopeConfig();
@@ -6758,7 +7061,7 @@ function showStatus() {
   console.log(`team:    ${cfg.team.length === 0 ? "(empty)" : cfg.team.join(", ")}`);
   console.log(`install: ${cfg.install}  (${cfg.install === "global" ? "~/.claude/skills/" : "<project>/.claude/skills/"})`);
   const dir = stateDir();
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     console.log(`state: (no projects tracked yet)`);
     return;
   }
@@ -6770,7 +7073,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync18(join28(dir, f), "utf-8"));
+      const s = JSON.parse(readFileSync21(join30(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})`);
@@ -6797,7 +7100,7 @@ function setInstall(loc) {
   }
   const cfg = loadScopeConfig();
   saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join28(homedir18(), ".claude", "skills") : "<cwd>/.claude/skills";
+  const path = loc === "global" ? join30(homedir20(), ".claude", "skills") : "<cwd>/.claude/skills";
   console.log(`Install location set to '${loc}'. New skills will be written to ${path}/<name>/SKILL.md.`);
 }
 function promoteSkill(name, cwd) {
@@ -6805,18 +7108,18 @@ function promoteSkill(name, cwd) {
     console.error("Usage: hivemind skillify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join28(cwd, ".claude", "skills", name);
-  const globalPath = join28(homedir18(), ".claude", "skills", name);
-  if (!existsSync25(join28(projectPath, "SKILL.md"))) {
+  const projectPath = join30(cwd, ".claude", "skills", name);
+  const globalPath = join30(homedir20(), ".claude", "skills", name);
+  if (!existsSync26(join30(projectPath, "SKILL.md"))) {
     console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
     process.exit(1);
   }
-  if (existsSync25(join28(globalPath, "SKILL.md"))) {
+  if (existsSync26(join30(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);
   }
-  mkdirSync10(dirname6(globalPath), { recursive: true });
-  renameSync5(projectPath, globalPath);
+  mkdirSync12(dirname7(globalPath), { recursive: true });
+  renameSync7(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
 function teamAdd(name) {
@@ -6922,7 +7225,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join28(homedir18(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join30(homedir20(), ".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" : ""}`);
@@ -6972,7 +7275,7 @@ async function unpullSkills(args) {
     all,
     legacyCleanup
   });
-  const dest = toRaw === "global" ? join28(homedir18(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join30(homedir20(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterParts = [];
   if (users.length > 0)
     filterParts.push(`users=${users.join(",")}`);
@@ -7068,13 +7371,13 @@ if (process.argv[1] && process.argv[1].endsWith("skillify.js")) {
 
 // dist/src/cli/update.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync20, realpathSync } from "node:fs";
-import { dirname as dirname8, sep } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync23, realpathSync } from "node:fs";
+import { dirname as dirname9, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/src/utils/version-check.js
-import { readFileSync as readFileSync19 } from "node:fs";
-import { dirname as dirname7, join as join29 } from "node:path";
+import { readFileSync as readFileSync22 } from "node:fs";
+import { dirname as dirname8, join as join31 } from "node:path";
 function isNewer(latest, current) {
   const parse = (v) => v.split(".").map(Number);
   const [la, lb, lc] = parse(latest);
@@ -7093,24 +7396,24 @@ function detectInstallKind(argv1) {
       return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
     }
   })();
-  let dir = dirname8(realArgv1);
+  let dir = dirname9(realArgv1);
   let installDir = null;
   for (let i = 0; i < 10; i++) {
     const pkgPath = `${dir}${sep}package.json`;
     try {
-      const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
       if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
         installDir = dir;
         break;
       }
     } catch {
     }
-    const parent = dirname8(dir);
+    const parent = dirname9(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  installDir ??= dirname8(realArgv1);
+  installDir ??= dirname9(realArgv1);
   if (realArgv1.includes(`${sep}_npx${sep}`) || realArgv1.includes(`${sep}.npx${sep}`)) {
     return { kind: "npx", installDir };
   }
@@ -7119,10 +7422,10 @@ function detectInstallKind(argv1) {
   }
   let gitDir = installDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync26(`${gitDir}${sep}.git`)) {
+    if (existsSync27(`${gitDir}${sep}.git`)) {
       return { kind: "local-dev", installDir };
     }
-    const parent = dirname8(gitDir);
+    const parent = dirname9(gitDir);
     if (parent === gitDir)
       break;
     gitDir = parent;
@@ -7265,12 +7568,28 @@ Usage:
 
 Semantic search (embeddings):
   hivemind embeddings install                Download @huggingface/transformers
-                                             once (~600 MB) into a shared dir
-                                             and symlink every detected agent
-                                             plugin to it. Idempotent.
-  hivemind embeddings uninstall [--prune]    Remove the per-agent symlinks.
-                                             --prune also deletes the shared dir.
-  hivemind embeddings status                 Show shared-deps + per-agent state.
+                                             once (~600 MB) into a shared dir,
+                                             symlink every detected agent
+                                             plugin to it, and set
+                                             embeddings.enabled = true in
+                                             ~/.deeplake/config.json. Idempotent.
+  hivemind embeddings enable                 Light opt-in: flip
+                                             embeddings.enabled = true in
+                                             ~/.deeplake/config.json. Use this
+                                             after \`disable\` to turn back on
+                                             without re-running install.
+  hivemind embeddings disable                Light opt-out: flip
+                                             embeddings.enabled = false and
+                                             SIGTERM the running daemon. Shared
+                                             deps stay on disk.
+  hivemind embeddings uninstall [--prune]    Full opt-out: remove the per-agent
+                                             symlinks, flip
+                                             embeddings.enabled = false, and
+                                             SIGTERM the daemon. --prune also
+                                             deletes the shared dir to reclaim
+                                             ~600 MB.
+  hivemind embeddings status                 Show config + shared-deps + per-
+                                             agent state.
 
   Add --with-embeddings to "hivemind install" (or "hivemind <agent> install")
   to run "embeddings install" automatically after installing the agent(s).
@@ -7340,7 +7659,7 @@ async function runInstallAll(args) {
     runSingleInstall(id);
   if (withEmbeddings) {
     log("");
-    enableEmbeddings();
+    installEmbeddings();
   }
   await maybeShowOrgChoice();
   log("");
@@ -7433,19 +7752,27 @@ async function main() {
   }
   if (cmd === "embeddings") {
     const sub = args[1];
-    if (sub === "install" || sub === "enable") {
+    if (sub === "install") {
+      installEmbeddings();
+      return;
+    }
+    if (sub === "enable") {
       enableEmbeddings();
       return;
     }
-    if (sub === "uninstall" || sub === "disable") {
-      disableEmbeddings({ prune: hasFlag(args.slice(2), "--prune") });
+    if (sub === "disable") {
+      disableEmbeddings();
+      return;
+    }
+    if (sub === "uninstall") {
+      uninstallEmbeddings({ prune: hasFlag(args.slice(2), "--prune") });
       return;
     }
     if (sub === "status") {
       statusEmbeddings();
       return;
     }
-    warn("Usage: hivemind embeddings install | uninstall [--prune] | status");
+    warn("Usage: hivemind embeddings install | enable | disable | uninstall [--prune] | status");
     process.exit(1);
   }
   if (AUTH_SUBCOMMANDS.has(cmd)) {
@@ -7459,7 +7786,7 @@ async function main() {
       runSingleInstall(cmd);
       if (hasFlag(args.slice(2), "--with-embeddings")) {
         log("");
-        enableEmbeddings();
+        installEmbeddings();
       }
     } else if (sub === "uninstall")
       runSingleUninstall(cmd);