@deeplake/hivemind 0.6.48 → 0.7.9

package/bundle/cli.js

@@ -1,4 +1,56 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/src/index-marker-store.js
+var index_marker_store_exports = {};
+__export(index_marker_store_exports, {
+  buildIndexMarkerPath: () => buildIndexMarkerPath,
+  getIndexMarkerDir: () => getIndexMarkerDir,
+  hasFreshIndexMarker: () => hasFreshIndexMarker,
+  writeIndexMarker: () => writeIndexMarker
+});
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join14 } from "node:path";
+import { tmpdir } from "node:os";
+function getIndexMarkerDir() {
+  return process.env.HIVEMIND_INDEX_MARKER_DIR ?? join14(tmpdir(), "hivemind-deeplake-indexes");
+}
+function buildIndexMarkerPath(workspaceId, orgId, table, suffix) {
+  const markerKey = [workspaceId, orgId, table, suffix].join("__").replace(/[^a-zA-Z0-9_.-]/g, "_");
+  return join14(getIndexMarkerDir(), `${markerKey}.json`);
+}
+function hasFreshIndexMarker(markerPath) {
+  if (!existsSync11(markerPath))
+    return false;
+  try {
+    const raw = JSON.parse(readFileSync8(markerPath, "utf-8"));
+    const updatedAt = raw.updatedAt ? new Date(raw.updatedAt).getTime() : NaN;
+    if (!Number.isFinite(updatedAt) || Date.now() - updatedAt > INDEX_MARKER_TTL_MS)
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeIndexMarker(markerPath) {
+  mkdirSync3(getIndexMarkerDir(), { recursive: true });
+  writeFileSync5(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
+}
+var INDEX_MARKER_TTL_MS;
+var init_index_marker_store = __esm({
+  "dist/src/index-marker-store.js"() {
+    "use strict";
+    INDEX_MARKER_TTL_MS = Number(process.env.HIVEMIND_INDEX_MARKER_TTL_MS ?? 6 * 60 * 6e4);
+  }
+});
 
 // dist/src/cli/install-claude.js
 import { execFileSync } from "node:child_process";
@@ -10,6 +62,19 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 var HOME = homedir();
 function pkgRoot() {
+  let dir = fileURLToPath(new URL(".", import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf-8"));
+      if (pkg.name === "@deeplake/hivemind" || pkg.name === "hivemind")
+        return dir;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
   return fileURLToPath(new URL("..", import.meta.url));
 }
 function ensureDir(path, mode = 493) {
@@ -112,6 +177,7 @@ function pluginAlreadyInstalled() {
     return false;
   return r.stdout.includes(PLUGIN_KEY);
 }
+var PLUGIN_SCOPES = ["user", "project", "local", "managed"];
 function installClaude() {
   requireClaudeCli();
   if (!marketplaceAlreadyAdded()) {
@@ -125,9 +191,15 @@ function installClaude() {
     if (!inst.ok) {
       throw new Error(`Failed to install hivemind plugin: ${inst.stderr.slice(0, 200)}`);
     }
+    log(`  Claude Code    installed via marketplace ${MARKETPLACE_SOURCE}`);
+  } else {
+    runClaude(["plugin", "marketplace", "update", MARKETPLACE_NAME]);
+    for (const scope of PLUGIN_SCOPES) {
+      runClaude(["plugin", "update", PLUGIN_KEY, "--scope", scope]);
+    }
+    log(`  Claude Code    refreshed via marketplace ${MARKETPLACE_SOURCE}`);
   }
   runClaude(["plugin", "enable", PLUGIN_KEY]);
-  log(`  Claude Code    installed via marketplace ${MARKETPLACE_SOURCE}`);
 }
 function uninstallClaude() {
   try {
@@ -187,7 +259,15 @@ function buildHooksJson() {
     }
   };
 }
-function isHivemindHookEntry(entry) {
+var HIVEMIND_BUNDLE_FILES = [
+  "session-start.js",
+  "session-start-setup.js",
+  "capture.js",
+  "pre-tool-use.js",
+  "stop.js",
+  "wiki-worker.js"
+];
+function isHivemindHookEntry(entry, pluginDir = PLUGIN_DIR) {
   if (!entry || typeof entry !== "object")
     return false;
   const e = entry;
@@ -196,9 +276,41 @@ function isHivemindHookEntry(entry) {
     if (!h || typeof h !== "object")
       return false;
     const cmd = h.command;
-    return typeof cmd === "string" && cmd.includes(`${PLUGIN_DIR}/bundle/`);
+    if (typeof cmd !== "string")
+      return false;
+    if (cmd.includes(`${pluginDir}/bundle/`))
+      return true;
+    return HIVEMIND_BUNDLE_FILES.some((f) => cmd.includes(`/bundle/${f}`));
+  });
+}
+function isForeignHivemindHookEntry(entry, pluginDir = PLUGIN_DIR) {
+  if (!isHivemindHookEntry(entry, pluginDir))
+    return false;
+  const e = entry;
+  const hooks = Array.isArray(e.hooks) ? e.hooks : [];
+  return hooks.every((h) => {
+    if (!h || typeof h !== "object")
+      return false;
+    const cmd = h.command;
+    if (typeof cmd !== "string")
+      return false;
+    return !cmd.includes(`${pluginDir}/bundle/`);
   });
 }
+function mergeHooks(existing, ours, pluginDir = PLUGIN_DIR) {
+  const existingHooks = existing.hooks && typeof existing.hooks === "object" ? existing.hooks : {};
+  const ourHooks = ours.hooks;
+  const merged = {};
+  for (const [event, entries] of Object.entries(existingHooks)) {
+    const surviving = (entries ?? []).filter((e) => !isHivemindHookEntry(e, pluginDir));
+    if (surviving.length)
+      merged[event] = surviving;
+  }
+  for (const [event, entries] of Object.entries(ourHooks)) {
+    merged[event] = [...merged[event] ?? [], ...entries ?? []];
+  }
+  return { ...existing, hooks: merged };
+}
 function mergeHooksJson(ours) {
   let existing = {};
   try {
@@ -210,18 +322,30 @@ function mergeHooksJson(ours) {
   } catch {
     warn(`  Codex          ${HOOKS_PATH} unparseable \u2014 ignoring prior content`);
   }
+  reportForeignHivemindHooks(existing);
+  return mergeHooks(existing, ours);
+}
+function reportForeignHivemindHooks(existing) {
   const existingHooks = existing.hooks && typeof existing.hooks === "object" ? existing.hooks : {};
-  const ourHooks = ours.hooks;
-  const merged = {};
-  for (const [event, entries] of Object.entries(existingHooks)) {
-    const surviving = (entries ?? []).filter((e) => !isHivemindHookEntry(e));
-    if (surviving.length)
-      merged[event] = surviving;
-  }
-  for (const [event, entries] of Object.entries(ourHooks)) {
-    merged[event] = [...merged[event] ?? [], ...entries ?? []];
+  const foreign = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(existingHooks)) {
+    for (const e of entries ?? []) {
+      if (!isForeignHivemindHookEntry(e))
+        continue;
+      const hooks = Array.isArray(e.hooks) ? e.hooks : [];
+      for (const h of hooks) {
+        const cmd = h?.command;
+        if (typeof cmd === "string")
+          foreign.add(cmd);
+      }
+    }
   }
-  return { ...existing, hooks: merged };
+  if (foreign.size === 0)
+    return;
+  warn(`  Codex          stripping ${foreign.size} hivemind hook(s) from a non-canonical path:`);
+  for (const cmd of foreign)
+    warn(`                   ${cmd}`);
+  warn(`                 (these were probably leftover from a local dev clone \u2014 re-add them manually if intentional)`);
 }
 function tryEnableCodexHooks() {
   try {
@@ -253,8 +377,28 @@ function installCodex() {
 }
 function uninstallCodex() {
   if (existsSync2(HOOKS_PATH)) {
-    unlinkSync2(HOOKS_PATH);
-    log(`  Codex          removed ${HOOKS_PATH}`);
+    let existing = {};
+    try {
+      const raw = JSON.parse(readFileSync3(HOOKS_PATH, "utf-8"));
+      if (raw && typeof raw === "object")
+        existing = raw;
+    } catch {
+      unlinkSync2(HOOKS_PATH);
+      log(`  Codex          removed unparseable ${HOOKS_PATH}`);
+      existing = {};
+    }
+    if (Object.keys(existing).length > 0) {
+      const stripped = mergeHooks(existing, { hooks: {} });
+      const survivingHooks = stripped.hooks ?? {};
+      const otherTopLevelKeys = Object.keys(stripped).filter((k) => k !== "hooks");
+      if (Object.keys(survivingHooks).length === 0 && otherTopLevelKeys.length === 0) {
+        unlinkSync2(HOOKS_PATH);
+        log(`  Codex          removed ${HOOKS_PATH}`);
+      } else {
+        writeJson(HOOKS_PATH, stripped);
+        log(`  Codex          stripped hivemind hooks from ${HOOKS_PATH}`);
+      }
+    }
   }
   if (existsSync2(SKILL_LINK)) {
     unlinkSync2(SKILL_LINK);
@@ -336,7 +480,7 @@ function isHivemindEntry(entry) {
   const cmd = entry.command;
   return typeof cmd === "string" && cmd.includes("/.cursor/hivemind/bundle/");
 }
-function mergeHooks(existing) {
+function mergeHooks2(existing) {
   const root = existing ?? { version: 1, hooks: {} };
   if (!root.version)
     root.version = 1;
@@ -375,7 +519,7 @@ function installCursor() {
   ensureDir(PLUGIN_DIR3);
   copyDir(srcBundle, join5(PLUGIN_DIR3, "bundle"));
   const existing = readJson(HOOKS_PATH2);
-  const merged = mergeHooks(existing);
+  const merged = mergeHooks2(existing);
   writeJson(HOOKS_PATH2, merged);
   writeVersionStamp(PLUGIN_DIR3, getVersion());
   log(`  Cursor         installed -> ${PLUGIN_DIR3}`);
@@ -3090,7 +3234,7 @@ function buildHooksBlock() {
     on_session_end: [buildHookEntry("session-end.js", 30)]
   };
 }
-function mergeHooks2(existing) {
+function mergeHooks3(existing) {
   const merged = { ...existing ?? {} };
   const ours = buildHooksBlock();
   for (const [event, entries] of Object.entries(ours)) {
@@ -3151,7 +3295,7 @@ function installHermes() {
     command: "node",
     args: [MCP_SERVER_PATH]
   };
-  cfg.hooks = mergeHooks2(cfg.hooks);
+  cfg.hooks = mergeHooks3(cfg.hooks);
   cfg.hooks_auto_accept = true;
   writeConfig(cfg);
   log(`  Hermes         config updated -> ${CONFIG_PATH} (mcp_servers + hooks + hooks_auto_accept)`);
@@ -3182,6 +3326,10 @@ function uninstallHermes() {
         delete cfg.hooks;
       touched = true;
     }
+    if ("hooks_auto_accept" in cfg) {
+      delete cfg.hooks_auto_accept;
+      touched = true;
+    }
     if (touched) {
       if (Object.keys(cfg).length === 0) {
         unlinkSync4(CONFIG_PATH);
@@ -3202,6 +3350,9 @@ var LEGACY_SKILL_DIR = join8(PI_AGENT_DIR, "skills", "hivemind-memory");
 var EXTENSIONS_DIR = join8(PI_AGENT_DIR, "extensions");
 var EXTENSION_PATH = join8(EXTENSIONS_DIR, "hivemind.ts");
 var VERSION_DIR = join8(PI_AGENT_DIR, ".hivemind");
+var WIKI_WORKER_DIR = join8(PI_AGENT_DIR, "hivemind");
+var WIKI_WORKER_PATH = join8(WIKI_WORKER_DIR, "wiki-worker.js");
+var SKILIFY_WORKER_PATH = join8(WIKI_WORKER_DIR, "skilify-worker.js");
 var HIVEMIND_BLOCK_START = "<!-- BEGIN hivemind-memory -->";
 var HIVEMIND_BLOCK_END = "<!-- END hivemind-memory -->";
 var HIVEMIND_BLOCK_BODY = `${HIVEMIND_BLOCK_START}
@@ -3281,10 +3432,26 @@ function installPi() {
   }
   ensureDir(EXTENSIONS_DIR);
   copyFileSync2(srcExtension, EXTENSION_PATH);
+  const srcWorker = join8(pkgRoot(), "pi", "bundle", "wiki-worker.js");
+  if (existsSync7(srcWorker)) {
+    ensureDir(WIKI_WORKER_DIR);
+    copyFileSync2(srcWorker, WIKI_WORKER_PATH);
+  }
+  const srcSkilifyWorker = join8(pkgRoot(), "pi", "bundle", "skilify-worker.js");
+  if (existsSync7(srcSkilifyWorker)) {
+    ensureDir(WIKI_WORKER_DIR);
+    copyFileSync2(srcSkilifyWorker, SKILIFY_WORKER_PATH);
+  }
   ensureDir(VERSION_DIR);
   writeVersionStamp(VERSION_DIR, getVersion());
   log(`  pi             AGENTS.md updated -> ${AGENTS_MD}`);
   log(`  pi             extension installed -> ${EXTENSION_PATH}`);
+  if (existsSync7(WIKI_WORKER_PATH)) {
+    log(`  pi             wiki-worker installed -> ${WIKI_WORKER_PATH}`);
+  }
+  if (existsSync7(SKILIFY_WORKER_PATH)) {
+    log(`  pi             skilify-worker installed -> ${SKILIFY_WORKER_PATH}`);
+  }
 }
 function uninstallPi() {
   if (existsSync7(LEGACY_SKILL_DIR)) {
@@ -3295,6 +3462,10 @@ function uninstallPi() {
     rmSync3(EXTENSION_PATH, { force: true });
     log(`  pi             removed extension ${EXTENSION_PATH}`);
   }
+  if (existsSync7(WIKI_WORKER_DIR)) {
+    rmSync3(WIKI_WORKER_DIR, { recursive: true, force: true });
+    log(`  pi             removed wiki-worker dir ${WIKI_WORKER_DIR}`);
+  }
   if (existsSync7(AGENTS_MD)) {
     const prior = readFileSync5(AGENTS_MD, "utf-8");
     const stripped = stripHivemindBlock(prior);
@@ -3311,43 +3482,228 @@ function uninstallPi() {
   }
 }
 
+// dist/src/cli/embeddings.js
+import { copyFileSync as copyFileSync3, chmodSync, existsSync as existsSync8, 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 join9 } from "node:path";
+var SHARED_DIR = join9(HOME, ".hivemind", "embed-deps");
+var SHARED_NODE_MODULES = join9(SHARED_DIR, "node_modules");
+var SHARED_DAEMON_PATH = join9(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: join9(home, ".codex", "hivemind") },
+    { id: "cursor", pluginDir: join9(home, ".cursor", "hivemind") },
+    { id: "hermes", pluginDir: join9(home, ".hermes", "hivemind") }
+  ];
+  for (const inst of fixed) {
+    if (existsSync8(join9(inst.pluginDir, "bundle")))
+      out.push(inst);
+  }
+  const ccCache = join9(home, ".claude", "plugins", "cache", "hivemind", "hivemind");
+  if (existsSync8(ccCache)) {
+    let entries = [];
+    try {
+      entries = readdirSync(ccCache);
+    } catch {
+    }
+    for (const ver of entries) {
+      const dir = join9(ccCache, ver);
+      try {
+        if (!statSync(dir).isDirectory())
+          continue;
+      } catch {
+        continue;
+      }
+      const candidates = [join9(dir, "bundle"), join9(dir, "claude-code", "bundle")];
+      if (candidates.some((p) => existsSync8(p))) {
+        out.push({ id: `claude (${ver})`, pluginDir: dir });
+      }
+    }
+  }
+  return out;
+}
+function isSharedDepsInstalled(sharedNodeModules = SHARED_NODE_MODULES) {
+  return existsSync8(join9(sharedNodeModules, TRANSFORMERS_PKG));
+}
+function isSymlinkToSharedDeps(linkPath, sharedNodeModules) {
+  if (!existsSync8(linkPath))
+    return false;
+  try {
+    if (!lstatSync2(linkPath).isSymbolicLink())
+      return false;
+    return readlinkSync(linkPath) === sharedNodeModules;
+  } catch {
+    return false;
+  }
+}
+function linkStateFor(install, sharedNodeModules = SHARED_NODE_MODULES) {
+  const link = join9(install.pluginDir, "node_modules");
+  if (!existsSync8(link) && !isSymbolicLink(link))
+    return { kind: "no-node-modules" };
+  try {
+    if (lstatSync2(link).isSymbolicLink()) {
+      const target = readlinkSync(link);
+      return target === sharedNodeModules ? { kind: "linked-to-shared" } : { kind: "linked-elsewhere", target };
+    }
+  } catch {
+    return { kind: "no-node-modules" };
+  }
+  return { kind: "owns-own-node-modules" };
+}
+function isSymbolicLink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function ensureSharedDeps() {
+  if (!isSharedDepsInstalled()) {
+    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(join9(SHARED_DIR, "package.json"), {
+      name: "hivemind-embed-deps",
+      version: "1.0.0",
+      private: true,
+      dependencies: { [TRANSFORMERS_PKG]: TRANSFORMERS_RANGE }
+    });
+    execFileSync3("npm", ["install", "--omit=dev", "--no-package-lock", "--no-audit", "--no-fund"], {
+      cwd: SHARED_DIR,
+      stdio: "inherit"
+    });
+  } else {
+    log(`  Embeddings     shared deps already present at ${SHARED_DIR}`);
+  }
+  ensureDir(SHARED_DIR);
+  const src = join9(pkgRoot(), "embeddings", "embed-daemon.js");
+  if (existsSync8(src)) {
+    copyFileSync3(src, SHARED_DAEMON_PATH);
+    chmodSync(SHARED_DAEMON_PATH, 493);
+  } else {
+    warn(`  Embeddings     standalone daemon bundle missing at ${src} (run 'npm run build' first)`);
+  }
+}
+function linkAgent(install) {
+  const link = join9(install.pluginDir, "node_modules");
+  symlinkForce(SHARED_NODE_MODULES, link);
+  log(`  Embeddings     linked ${install.id.padEnd(20)} -> shared deps`);
+}
+function enableEmbeddings() {
+  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;
+  }
+  for (const inst of installs)
+    linkAgent(inst);
+  log(`  Embeddings     enabled. Restart your agents to pick up.`);
+}
+function disableEmbeddings(opts) {
+  const installs = findHivemindInstalls();
+  for (const inst of installs) {
+    const link = join9(inst.pluginDir, "node_modules");
+    if (isSymlinkToSharedDeps(link, SHARED_NODE_MODULES)) {
+      unlinkSync5(link);
+      log(`  Embeddings     unlinked ${inst.id}`);
+    }
+  }
+  if (opts?.prune && existsSync8(SHARED_DIR)) {
+    rmSync4(SHARED_DIR, { recursive: true, force: true });
+    log(`  Embeddings     pruned ${SHARED_DIR}`);
+  }
+}
+function statusEmbeddings() {
+  log(`Shared deps:   ${SHARED_DIR}`);
+  log(`Installed:     ${isSharedDepsInstalled() ? "yes" : "no"}`);
+  log(`Daemon:        ${existsSync8(SHARED_DAEMON_PATH) ? SHARED_DAEMON_PATH : "(not present)"}`);
+  log("");
+  log(`Agent installs:`);
+  const installs = findHivemindInstalls();
+  if (installs.length === 0) {
+    log(`  (none detected)`);
+    return;
+  }
+  for (const inst of installs) {
+    const state = linkStateFor(inst);
+    let label;
+    switch (state.kind) {
+      case "linked-to-shared":
+        label = "\u2713 linked \u2192 shared";
+        break;
+      case "no-node-modules":
+        label = "\u2717 not linked (embeddings disabled)";
+        break;
+      case "owns-own-node-modules":
+        label = "\u25B3 has its own node_modules (not shared)";
+        break;
+      case "linked-elsewhere":
+        label = `\u25B3 linked \u2192 ${state.target}`;
+        break;
+    }
+    log(`  ${inst.id.padEnd(20)} ${label}`);
+    log(`  ${" ".repeat(20)}   ${inst.pluginDir}`);
+  }
+}
+
 // dist/src/cli/auth.js
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // dist/src/commands/auth.js
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
-import { join as join9 } from "node:path";
-import { homedir as homedir2 } from "node:os";
 import { execSync } from "node:child_process";
-var CONFIG_DIR = join9(homedir2(), ".deeplake");
-var CREDS_PATH = join9(CONFIG_DIR, "credentials.json");
-var DEFAULT_API_URL = "https://api.deeplake.ai";
+
+// dist/src/utils/client-header.js
+var DEEPLAKE_CLIENT_HEADER = "X-Deeplake-Client";
+function deeplakeClientValue() {
+  return "hivemind";
+}
+function deeplakeClientHeader() {
+  return { [DEEPLAKE_CLIENT_HEADER]: deeplakeClientValue() };
+}
+
+// dist/src/commands/auth-creds.js
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2, unlinkSync as unlinkSync6 } from "node:fs";
+import { join as join10 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function configDir() {
+  return join10(homedir2(), ".deeplake");
+}
+function credsPath() {
+  return join10(configDir(), "credentials.json");
+}
 function loadCredentials() {
-  if (!existsSync8(CREDS_PATH))
-    return null;
   try {
-    return JSON.parse(readFileSync6(CREDS_PATH, "utf-8"));
+    return JSON.parse(readFileSync6(credsPath(), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveCredentials(creds) {
-  if (!existsSync8(CONFIG_DIR))
-    mkdirSync2(CONFIG_DIR, { recursive: true, mode: 448 });
-  writeFileSync4(CREDS_PATH, JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
+  mkdirSync2(configDir(), { recursive: true, mode: 448 });
+  writeFileSync4(credsPath(), JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), { mode: 384 });
 }
 function deleteCredentials() {
-  if (existsSync8(CREDS_PATH)) {
-    unlinkSync5(CREDS_PATH);
+  try {
+    unlinkSync6(credsPath());
     return true;
+  } catch {
+    return false;
   }
-  return false;
 }
+
+// dist/src/commands/auth.js
+var DEFAULT_API_URL = "https://api.deeplake.ai";
 async function apiGet(path, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
   };
   if (orgId)
     headers["X-Activeloop-Org-Id"] = orgId;
@@ -3359,7 +3715,8 @@ async function apiGet(path, token, apiUrl, orgId) {
 async function apiPost(path, body, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
   };
   if (orgId)
     headers["X-Activeloop-Org-Id"] = orgId;
@@ -3371,7 +3728,8 @@ async function apiPost(path, body, token, apiUrl, orgId) {
 async function apiDelete(path, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
   };
   if (orgId)
     headers["X-Activeloop-Org-Id"] = orgId;
@@ -3382,7 +3740,7 @@ async function apiDelete(path, token, apiUrl, orgId) {
 async function requestDeviceCode(apiUrl = DEFAULT_API_URL) {
   const resp = await fetch(`${apiUrl}/auth/device/code`, {
     method: "POST",
-    headers: { "Content-Type": "application/json" }
+    headers: { "Content-Type": "application/json", ...deeplakeClientHeader() }
   });
   if (!resp.ok)
     throw new Error(`Device flow unavailable: HTTP ${resp.status}`);
@@ -3391,7 +3749,7 @@ async function requestDeviceCode(apiUrl = DEFAULT_API_URL) {
 async function pollForToken(deviceCode, apiUrl = DEFAULT_API_URL) {
   const resp = await fetch(`${apiUrl}/auth/device/token`, {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: { "Content-Type": "application/json", ...deeplakeClientHeader() },
     body: JSON.stringify({ device_code: deviceCode })
   });
   if (resp.ok)
@@ -3517,9 +3875,9 @@ Using: ${orgName}
 }
 
 // dist/src/cli/auth.js
-var CREDS_PATH2 = join10(HOME, ".deeplake", "credentials.json");
+var CREDS_PATH = join11(HOME, ".deeplake", "credentials.json");
 function isLoggedIn() {
-  return existsSync9(CREDS_PATH2) && loadCredentials() !== null;
+  return existsSync9(CREDS_PATH) && loadCredentials() !== null;
 }
 async function ensureLoggedIn() {
   if (isLoggedIn())
@@ -3553,11 +3911,11 @@ async function maybeShowOrgChoice() {
 
 // dist/src/config.js
 import { readFileSync as readFileSync7, existsSync as existsSync10 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { homedir as homedir3, userInfo } from "node:os";
 function loadConfig() {
   const home = homedir3();
-  const credPath = join11(home, ".deeplake", "credentials.json");
+  const credPath = join12(home, ".deeplake", "credentials.json");
   let creds = null;
   if (existsSync10(credPath)) {
     try {
@@ -3579,22 +3937,20 @@ function loadConfig() {
     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",
-    memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join11(home, ".deeplake", "memory")
+    skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join12(home, ".deeplake", "memory")
   };
 }
 
 // dist/src/deeplake-api.js
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join13 } from "node:path";
-import { tmpdir } from "node:os";
 
 // dist/src/utils/debug.js
 import { appendFileSync } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 var DEBUG = process.env.HIVEMIND_DEBUG === "1";
-var LOG = join12(homedir4(), ".deeplake", "hook-debug.log");
+var LOG = join13(homedir4(), ".deeplake", "hook-debug.log");
 function log2(tag, msg) {
   if (!DEBUG)
     return;
@@ -3606,8 +3962,24 @@ function log2(tag, msg) {
 function sqlStr(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/\0/g, "").replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
 }
+function sqlIdent(name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error(`Invalid SQL identifier: ${JSON.stringify(name)}`);
+  }
+  return name;
+}
+
+// dist/src/embeddings/columns.js
+var SUMMARY_EMBEDDING_COL = "summary_embedding";
+var MESSAGE_EMBEDDING_COL = "message_embedding";
 
 // dist/src/deeplake-api.js
+var indexMarkerStorePromise = null;
+function getIndexMarkerStore() {
+  if (!indexMarkerStorePromise)
+    indexMarkerStorePromise = Promise.resolve().then(() => (init_index_marker_store(), index_marker_store_exports));
+  return indexMarkerStorePromise;
+}
 var log3 = (msg) => log2("sdk", msg);
 function summarizeSql(sql, maxLen = 220) {
   const compact = sql.replace(/\s+/g, " ").trim();
@@ -3627,7 +3999,6 @@ var MAX_RETRIES = 3;
 var BASE_DELAY_MS = 500;
 var MAX_CONCURRENCY = 5;
 var QUERY_TIMEOUT_MS = Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
-var INDEX_MARKER_TTL_MS = Number(process.env.HIVEMIND_INDEX_MARKER_TTL_MS ?? 6 * 60 * 6e4);
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -3647,9 +4018,6 @@ function isTransientHtml403(text) {
   const body = text.toLowerCase();
   return body.includes("<html") || body.includes("403 forbidden") || body.includes("cloudflare") || body.includes("nginx");
 }
-function getIndexMarkerDir() {
-  return process.env.HIVEMIND_INDEX_MARKER_DIR ?? join13(tmpdir(), "hivemind-deeplake-indexes");
-}
 var Semaphore = class {
   max;
   waiting = [];
@@ -3718,7 +4086,8 @@ var DeeplakeApi = class {
           headers: {
             Authorization: `Bearer ${this.token}`,
             "Content-Type": "application/json",
-            "X-Activeloop-Org-Id": this.orgId
+            "X-Activeloop-Org-Id": this.orgId,
+            ...deeplakeClientHeader()
           },
           signal,
           body: JSON.stringify({ query: sql })
@@ -3745,7 +4114,8 @@ var DeeplakeApi = class {
       }
       const text = await resp.text().catch(() => "");
       const retryable403 = isSessionInsertQuery(sql) && (resp.status === 401 || resp.status === 403 && (text.length === 0 || isTransientHtml403(text)));
-      if (attempt < MAX_RETRIES && (RETRYABLE_CODES.has(resp.status) || retryable403)) {
+      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);
@@ -3779,7 +4149,7 @@ var DeeplakeApi = class {
     const lud = row.lastUpdateDate ?? ts;
     const exists = await this.query(`SELECT path FROM "${this.tableName}" WHERE path = '${sqlStr(row.path)}' LIMIT 1`);
     if (exists.length > 0) {
-      let setClauses = `summary = E'${sqlStr(row.contentText)}', mime_type = '${sqlStr(row.mimeType)}', size_bytes = ${row.sizeBytes}, last_update_date = '${lud}'`;
+      let setClauses = `summary = E'${sqlStr(row.contentText)}', ${SUMMARY_EMBEDDING_COL} = NULL, mime_type = '${sqlStr(row.mimeType)}', size_bytes = ${row.sizeBytes}, last_update_date = '${lud}'`;
       if (row.project !== void 0)
         setClauses += `, project = '${sqlStr(row.project)}'`;
       if (row.description !== void 0)
@@ -3787,8 +4157,8 @@ var DeeplakeApi = class {
       await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(row.path)}'`);
     } else {
       const id = randomUUID();
-      let cols = "id, path, filename, summary, mime_type, size_bytes, creation_date, last_update_date";
-      let vals = `'${id}', '${sqlStr(row.path)}', '${sqlStr(row.filename)}', E'${sqlStr(row.contentText)}', '${sqlStr(row.mimeType)}', ${row.sizeBytes}, '${cd}', '${lud}'`;
+      let cols = `id, path, filename, summary, ${SUMMARY_EMBEDDING_COL}, mime_type, size_bytes, creation_date, last_update_date`;
+      let vals = `'${id}', '${sqlStr(row.path)}', '${sqlStr(row.filename)}', E'${sqlStr(row.contentText)}', NULL, '${sqlStr(row.mimeType)}', ${row.sizeBytes}, '${cd}', '${lud}'`;
       if (row.project !== void 0) {
         cols += ", project";
         vals += `, '${sqlStr(row.project)}'`;
@@ -3813,48 +4183,83 @@ var DeeplakeApi = class {
   buildLookupIndexName(table, suffix) {
     return `idx_${table}_${suffix}`.replace(/[^a-zA-Z0-9_]/g, "_");
   }
-  getLookupIndexMarkerPath(table, suffix) {
-    const markerKey = [
-      this.workspaceId,
-      this.orgId,
-      table,
-      suffix
-    ].join("__").replace(/[^a-zA-Z0-9_.-]/g, "_");
-    return join13(getIndexMarkerDir(), `${markerKey}.json`);
-  }
-  hasFreshLookupIndexMarker(table, suffix) {
-    const markerPath = this.getLookupIndexMarkerPath(table, suffix);
-    if (!existsSync11(markerPath))
-      return false;
-    try {
-      const raw = JSON.parse(readFileSync8(markerPath, "utf-8"));
-      const updatedAt = raw.updatedAt ? new Date(raw.updatedAt).getTime() : NaN;
-      if (!Number.isFinite(updatedAt) || Date.now() - updatedAt > INDEX_MARKER_TTL_MS)
-        return false;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  markLookupIndexReady(table, suffix) {
-    mkdirSync3(getIndexMarkerDir(), { recursive: true });
-    writeFileSync5(this.getLookupIndexMarkerPath(table, suffix), JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
-  }
   async ensureLookupIndex(table, suffix, columnsSql) {
-    if (this.hasFreshLookupIndexMarker(table, suffix))
+    const markers = await getIndexMarkerStore();
+    const markerPath = markers.buildIndexMarkerPath(this.workspaceId, this.orgId, table, suffix);
+    if (markers.hasFreshIndexMarker(markerPath))
       return;
     const indexName = this.buildLookupIndexName(table, suffix);
     try {
       await this.query(`CREATE INDEX IF NOT EXISTS "${indexName}" ON "${table}" ${columnsSql}`);
-      this.markLookupIndexReady(table, suffix);
+      markers.writeIndexMarker(markerPath);
     } catch (e) {
       if (isDuplicateIndexError(e)) {
-        this.markLookupIndexReady(table, suffix);
+        markers.writeIndexMarker(markerPath);
         return;
       }
       log3(`index "${indexName}" skipped: ${e.message}`);
     }
   }
+  /**
+   * Ensure a vector column exists on the given table.
+   *
+   * The previous implementation always issued `ALTER TABLE ADD COLUMN IF NOT
+   * EXISTS …` on every SessionStart. On a long-running workspace that's
+   * already migrated, every call returns 500 "Column already exists" — noisy
+   * in the log and a wasted round-trip. Worse, the very first call after the
+   * column is genuinely added triggers Deeplake's post-ALTER `vector::at`
+   * window (~30s) during which subsequent INSERTs fail; minimising the
+   * number of ALTER calls minimises exposure to that window.
+   *
+   * New flow:
+   *   1. Check the local marker file (mirrors ensureLookupIndex). If fresh,
+   *      return — zero network calls.
+   *   2. SELECT 1 FROM information_schema.columns WHERE table_name = T AND
+   *      column_name = C. Read-only, idempotent, can't tickle the post-ALTER
+   *      bug. If the column is present → mark + return.
+   *   3. Only if step 2 says the column is missing, fall back to ALTER ADD
+   *      COLUMN IF NOT EXISTS. Mark on success, also mark if Deeplake reports
+   *      "already exists" (race: another client added it between our SELECT
+   *      and ALTER).
+   *
+   * Marker uses the same dir / TTL as ensureLookupIndex so both schema
+   * caches share an opt-out (HIVEMIND_INDEX_MARKER_DIR) and a TTL knob.
+   */
+  async ensureEmbeddingColumn(table, column) {
+    await this.ensureColumn(table, column, "FLOAT4[]");
+  }
+  /**
+   * Generic marker-gated column migration. Same SELECT-then-ALTER flow as
+   * ensureEmbeddingColumn, parameterized by SQL type so it can patch up any
+   * column that was added to the schema after the table was originally
+   * created. Used today for `summary_embedding`, `message_embedding`, and
+   * the `agent` column (added 2026-04-11) — the latter has no fallback if
+   * a user upgraded over a pre-2026-04-11 table, so every INSERT fails
+   * with `column "agent" does not exist`.
+   */
+  async ensureColumn(table, column, sqlType) {
+    const markers = await getIndexMarkerStore();
+    const markerPath = markers.buildIndexMarkerPath(this.workspaceId, this.orgId, table, `col_${column}`);
+    if (markers.hasFreshIndexMarker(markerPath))
+      return;
+    const colCheck = `SELECT 1 FROM information_schema.columns WHERE table_name = '${sqlStr(table)}' AND column_name = '${sqlStr(column)}' AND table_schema = '${sqlStr(this.workspaceId)}' LIMIT 1`;
+    const rows = await this.query(colCheck);
+    if (rows.length > 0) {
+      markers.writeIndexMarker(markerPath);
+      return;
+    }
+    try {
+      await this.query(`ALTER TABLE "${table}" ADD COLUMN ${column} ${sqlType}`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!/already exists/i.test(msg))
+        throw e;
+      const recheck = await this.query(colCheck);
+      if (recheck.length === 0)
+        throw e;
+    }
+    markers.writeIndexMarker(markerPath);
+  }
   /** List all tables in the workspace (with retry). */
   async listTables(forceRefresh = false) {
     if (!forceRefresh && this._tablesCache)
@@ -3870,7 +4275,8 @@ var DeeplakeApi = class {
         const resp = await fetch(`${this.apiUrl}/workspaces/${this.workspaceId}/tables`, {
           headers: {
             Authorization: `Bearer ${this.token}`,
-            "X-Activeloop-Org-Id": this.orgId
+            "X-Activeloop-Org-Id": this.orgId,
+            ...deeplakeClientHeader()
           }
         });
         if (resp.ok) {
@@ -3895,29 +4301,84 @@ var DeeplakeApi = class {
     }
     return { tables: [], cacheable: false };
   }
+  /**
+   * Run a `CREATE TABLE` with an extra outer retry budget. The base
+   * `query()` already retries 3 times on fetch errors (~3.5s total), but a
+   * failed CREATE is permanent corruption — every subsequent SELECT against
+   * the missing table fails. Wrapping in an outer loop with longer backoff
+   * (2s, 5s, then 10s) gives us ~17s of reach across transient network
+   * blips before giving up. Failures still propagate; getApi() resets its
+   * cache on init failure (openclaw plugin) so the next call retries the
+   * whole init flow.
+   */
+  async createTableWithRetry(sql, label) {
+    const OUTER_BACKOFFS_MS = [2e3, 5e3, 1e4];
+    let lastErr = null;
+    for (let attempt = 0; attempt <= OUTER_BACKOFFS_MS.length; attempt++) {
+      try {
+        await this.query(sql);
+        return;
+      } catch (err) {
+        lastErr = err;
+        const msg = err instanceof Error ? err.message : String(err);
+        log3(`CREATE TABLE "${label}" attempt ${attempt + 1}/${OUTER_BACKOFFS_MS.length + 1} failed: ${msg}`);
+        if (attempt < OUTER_BACKOFFS_MS.length) {
+          await sleep(OUTER_BACKOFFS_MS[attempt]);
+        }
+      }
+    }
+    throw lastErr;
+  }
   /** Create the memory table if it doesn't already exist. Migrate columns on existing tables. */
   async ensureTable(name) {
-    const tbl = name ?? this.tableName;
+    const tbl = sqlIdent(name ?? this.tableName);
     const tables = await this.listTables();
     if (!tables.includes(tbl)) {
       log3(`table "${tbl}" not found, creating`);
-      await this.query(`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 '', 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 '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`);
+      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 '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`, tbl);
       log3(`table "${tbl}" created`);
       if (!tables.includes(tbl))
         this._tablesCache = [...tables, tbl];
     }
+    await this.ensureEmbeddingColumn(tbl, SUMMARY_EMBEDDING_COL);
+    await this.ensureColumn(tbl, "agent", "TEXT NOT NULL DEFAULT ''");
   }
   /** Create the sessions table (uses JSONB for message since every row is a JSON event). */
   async ensureSessionsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(`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 '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`, safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.ensureEmbeddingColumn(safe, MESSAGE_EMBEDDING_COL);
+    await this.ensureColumn(safe, "agent", "TEXT NOT NULL DEFAULT ''");
+    await this.ensureLookupIndex(safe, "path_creation_date", `("path", "creation_date")`);
+  }
+  /**
+   * Create the skills table.
+   *
+   * One row per skill version. Workers INSERT a fresh row on every KEEP /
+   * MERGE rather than UPDATE-ing in place, so the full version history is
+   * recoverable. Uniqueness in the *current* state is by (project_key, name)
+   * — newer rows shadow older ones at read time (ORDER BY version DESC).
+   * This sidesteps the Deeplake UPDATE-coalescing quirk that bit the wiki
+   * worker.
+   */
+  async ensureSkillsTable(name) {
+    const safe = sqlIdent(name);
     const tables = await this.listTables();
-    if (!tables.includes(name)) {
-      log3(`table "${name}" not found, creating`);
-      await this.query(`CREATE TABLE IF NOT EXISTS "${name}" (id TEXT NOT NULL DEFAULT '', path TEXT NOT NULL DEFAULT '', filename TEXT NOT NULL DEFAULT '', message JSONB, 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 '', creation_date TEXT NOT NULL DEFAULT '', last_update_date TEXT NOT NULL DEFAULT '') USING deeplake`);
-      log3(`table "${name}" created`);
-      if (!tables.includes(name))
-        this._tablesCache = [...tables, name];
+    if (!tables.includes(safe)) {
+      log3(`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`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
     }
-    await this.ensureLookupIndex(name, "path_creation_date", `("path", "creation_date")`);
+    await this.ensureLookupIndex(safe, "project_key_name", `("project_key", "name")`);
   }
 };
 
@@ -4097,8 +4558,24 @@ async function runAuthCommand(args) {
           console.log(`Org not found: ${target}`);
           process.exit(1);
         }
+        const prevWs = creds.workspaceId ?? "default";
+        const lcPrev = prevWs.toLowerCase();
+        const wsList = await listWorkspaces(creds.token, apiUrl, match.id);
+        const matchedWs = wsList.find((w) => w.id === prevWs || w.name && w.name.toLowerCase() === lcPrev);
         await switchOrg(match.id, match.name);
         console.log(`Switched to org: ${match.name}`);
+        if (!matchedWs) {
+          if (prevWs !== "default") {
+            await switchWorkspace("default");
+            console.log(`Workspace '${prevWs}' is not in org '${match.name}'. Reset workspace to 'default'.`);
+            if (wsList.length > 0) {
+              console.log(`Available workspaces: ${wsList.map((w) => w.name || w.id).join(", ")}`);
+            }
+          }
+        } else if (matchedWs.id !== prevWs) {
+          await switchWorkspace(matchedWs.id);
+          console.log(`Workspace name '${prevWs}' resolved to id '${matchedWs.id}' in org '${match.name}'.`);
+        }
       } else {
         console.log("Usage: org list | org switch <name-or-id>");
       }
@@ -4110,7 +4587,7 @@ async function runAuthCommand(args) {
         process.exit(1);
       }
       const ws = await listWorkspaces(creds.token, apiUrl, creds.orgId);
-      ws.forEach((w) => console.log(`${w.id}  ${w.name}`));
+      ws.forEach((w) => console.log(w.name || w.id));
       break;
     }
     case "workspace": {
@@ -4118,14 +4595,34 @@ async function runAuthCommand(args) {
         console.log("Not logged in.");
         process.exit(1);
       }
-      const wsId = args[1];
-      if (!wsId) {
-        console.log("Usage: workspace <id>");
-        process.exit(1);
+      const sub = args[1];
+      if (sub === "list") {
+        const wsList = await listWorkspaces(creds.token, apiUrl, creds.orgId);
+        wsList.forEach((w) => console.log(w.name || w.id));
+        break;
       }
-      await switchWorkspace(wsId);
-      console.log(`Switched to workspace: ${wsId}`);
-      break;
+      if (sub === "switch") {
+        const target = args[2];
+        if (!target) {
+          console.log("Usage: workspace switch <name-or-id>");
+          process.exit(1);
+        }
+        const wsList = await listWorkspaces(creds.token, apiUrl, creds.orgId);
+        const lcTarget = target.toLowerCase();
+        const match = wsList.find((w) => w.id === target || w.name && w.name.toLowerCase() === lcTarget);
+        if (!match) {
+          console.log(`Workspace not found: ${target}`);
+          if (wsList.length > 0) {
+            console.log(`Available workspaces: ${wsList.map((w) => w.name || w.id).join(", ")}`);
+          }
+          process.exit(1);
+        }
+        await switchWorkspace(match.id);
+        console.log(`Switched to workspace: ${match.name || match.id}`);
+        break;
+      }
+      console.log("Usage: workspace list | workspace switch <name-or-id>");
+      process.exit(1);
     }
     case "invite": {
       if (!creds) {
@@ -4212,6 +4709,699 @@ if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
   });
 }
 
+// dist/src/commands/skilify.js
+import { readdirSync as readdirSync3, existsSync as existsSync15, readFileSync as readFileSync12, mkdirSync as mkdirSync7, renameSync as renameSync2 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname2, join as join18 } from "node:path";
+
+// dist/src/skilify/scope-config.js
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join15 } from "node:path";
+var STATE_DIR = join15(homedir5(), ".deeplake", "state", "skilify");
+var CONFIG_PATH2 = join15(STATE_DIR, "config.json");
+var DEFAULT = { scope: "me", team: [], install: "project" };
+function loadScopeConfig() {
+  if (!existsSync12(CONFIG_PATH2))
+    return DEFAULT;
+  try {
+    const raw = JSON.parse(readFileSync9(CONFIG_PATH2, "utf-8"));
+    const scope = raw.scope === "team" || raw.scope === "org" ? raw.scope : "me";
+    const team = Array.isArray(raw.team) ? raw.team.filter((s) => typeof s === "string") : [];
+    const install = raw.install === "global" ? "global" : "project";
+    return { scope, team, install };
+  } catch {
+    return DEFAULT;
+  }
+}
+function saveScopeConfig(cfg) {
+  mkdirSync4(STATE_DIR, { recursive: true });
+  writeFileSync6(CONFIG_PATH2, JSON.stringify(cfg, null, 2));
+}
+
+// dist/src/skilify/pull.js
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, renameSync } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join17 } from "node:path";
+
+// dist/src/skilify/skill-writer.js
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join16 } from "node:path";
+function assertValidSkillName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`invalid skill name: empty or non-string`);
+  }
+  if (name.length > 100) {
+    throw new Error(`invalid skill name: too long (${name.length} chars)`);
+  }
+  if (name.includes("/") || name.includes("\\") || name.includes("..")) {
+    throw new Error(`invalid skill name: contains path separator or '..': ${name}`);
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name)) {
+    throw new Error(`invalid skill name: must be kebab-case (lowercase a-z, 0-9, hyphen): ${name}`);
+  }
+}
+function parseFrontmatter(text) {
+  if (!text.startsWith("---\n") && !text.startsWith("---\r\n"))
+    return null;
+  const end = text.indexOf("\n---", 4);
+  if (end < 0)
+    return null;
+  const head = text.slice(4, end).trim();
+  const body = text.slice(end + 4).replace(/^\r?\n/, "");
+  const fm = { source_sessions: [] };
+  let mode = "kv";
+  for (const raw of head.split(/\r?\n/)) {
+    if (mode === "sources") {
+      const m2 = raw.match(/^\s+-\s+(.+)$/);
+      if (m2) {
+        fm.source_sessions.push(m2[1].trim());
+        continue;
+      }
+      mode = "kv";
+    }
+    if (raw.startsWith("source_sessions:")) {
+      mode = "sources";
+      continue;
+    }
+    const m = raw.match(/^([a-zA-Z_]+):\s*(.*)$/);
+    if (!m)
+      continue;
+    const [, k, v] = m;
+    let val = v;
+    if (v.startsWith('"') && v.endsWith('"')) {
+      try {
+        val = JSON.parse(v);
+      } catch {
+      }
+    } else if (k === "version") {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n))
+        val = n;
+    }
+    fm[k] = val;
+  }
+  return { fm, body };
+}
+
+// dist/src/skilify/pull.js
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+}
+function buildPullSql(args) {
+  const where = [];
+  if (args.users.length > 0) {
+    const list = args.users.map((u) => `'${esc(u)}'`).join(", ");
+    where.push(`author IN (${list})`);
+  }
+  if (args.skillName) {
+    where.push(`name = '${esc(args.skillName)}'`);
+  }
+  const whereClause = where.length > 0 ? ` WHERE ${where.join(" AND ")}` : "";
+  return `SELECT name, project, project_key, body, version, source_agent, scope, author, description, trigger_text, source_sessions, install, created_at, updated_at FROM "${args.tableName}"${whereClause} ORDER BY project_key ASC, name ASC, version DESC`;
+}
+function isMissingTableError(message) {
+  if (!message)
+    return false;
+  return /Table does not exist|relation .* does not exist|no such table/i.test(message);
+}
+function resolvePullDestination(install, cwd) {
+  if (install === "global")
+    return join17(homedir7(), ".claude", "skills");
+  if (!cwd)
+    throw new Error("install=project requires a cwd");
+  return join17(cwd, ".claude", "skills");
+}
+function selectLatestPerName(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of rows) {
+    const name = String(r.name ?? "");
+    const projectKey = String(r.project_key ?? "");
+    if (!name)
+      continue;
+    const key = `${projectKey}\0${name}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(r);
+  }
+  return out;
+}
+function renderSkillFile(row) {
+  const sources = parseSourceSessions(row.source_sessions);
+  const fm = {
+    name: String(row.name ?? ""),
+    description: String(row.description ?? ""),
+    trigger: typeof row.trigger_text === "string" && row.trigger_text.length > 0 ? String(row.trigger_text) : void 0,
+    source_sessions: sources,
+    version: Number(row.version ?? 1),
+    created_by_agent: String(row.source_agent ?? "unknown"),
+    created_at: String(row.created_at ?? (/* @__PURE__ */ new Date()).toISOString()),
+    updated_at: String(row.updated_at ?? (/* @__PURE__ */ new Date()).toISOString())
+  };
+  const body = String(row.body ?? "").trim();
+  return `${renderFrontmatter(fm)}
+
+${body}
+`;
+}
+function parseSourceSessions(v) {
+  if (Array.isArray(v))
+    return v.map(String);
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v);
+      if (Array.isArray(parsed))
+        return parsed.map(String);
+    } catch {
+    }
+  }
+  return [];
+}
+function renderFrontmatter(fm) {
+  const lines = ["---"];
+  lines.push(`name: ${fm.name}`);
+  lines.push(`description: ${JSON.stringify(fm.description)}`);
+  if (fm.trigger)
+    lines.push(`trigger: ${JSON.stringify(fm.trigger)}`);
+  lines.push(`source_sessions:`);
+  for (const s of fm.source_sessions)
+    lines.push(`  - ${s}`);
+  lines.push(`version: ${fm.version}`);
+  lines.push(`created_by_agent: ${fm.created_by_agent}`);
+  lines.push(`created_at: ${fm.created_at}`);
+  lines.push(`updated_at: ${fm.updated_at}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+function readLocalVersion(path) {
+  if (!existsSync14(path))
+    return null;
+  try {
+    const text = readFileSync11(path, "utf-8");
+    const parsed = parseFrontmatter(text);
+    if (!parsed)
+      return null;
+    const v = parsed.fm.version;
+    return typeof v === "number" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function decideAction(args) {
+  const shouldWrite = args.localVersion === null || args.remoteVersion > args.localVersion || args.force;
+  if (!shouldWrite)
+    return "skipped";
+  return args.dryRun ? "dryrun" : "wrote";
+}
+async function runPull(opts) {
+  const sql = buildPullSql({
+    tableName: opts.tableName,
+    users: opts.users,
+    skillName: opts.skillName
+  });
+  let rows = [];
+  try {
+    rows = await opts.query(sql);
+  } catch (e) {
+    if (isMissingTableError(e?.message))
+      rows = [];
+    else
+      throw e;
+  }
+  const latest = selectLatestPerName(rows);
+  const root = resolvePullDestination(opts.install, opts.cwd);
+  const summary = { scanned: latest.length, wrote: 0, skipped: 0, dryrun: 0, entries: [] };
+  for (const row of latest) {
+    const name = String(row.name ?? "");
+    if (!name)
+      continue;
+    try {
+      assertValidSkillName(name);
+    } catch (e) {
+      summary.entries.push({
+        name,
+        remoteVersion: Number(row.version ?? 1),
+        localVersion: null,
+        action: "skipped",
+        destination: "(invalid name \u2014 skipped)",
+        author: String(row.author ?? ""),
+        sourceAgent: String(row.source_agent ?? "")
+      });
+      summary.skipped++;
+      continue;
+    }
+    const projectKey = String(row.project_key ?? "");
+    const skillDir = projectKey ? join17(root, projectKey, name) : join17(root, name);
+    const skillFile = join17(skillDir, "SKILL.md");
+    const remoteVersion = Number(row.version ?? 1);
+    const localVersion = readLocalVersion(skillFile);
+    const action = decideAction({
+      remoteVersion,
+      localVersion,
+      force: opts.force ?? false,
+      dryRun: opts.dryRun ?? false
+    });
+    if (action === "wrote") {
+      mkdirSync6(skillDir, { recursive: true });
+      if (existsSync14(skillFile)) {
+        try {
+          renameSync(skillFile, `${skillFile}.bak`);
+        } catch {
+        }
+      }
+      writeFileSync8(skillFile, renderSkillFile(row));
+    }
+    summary.entries.push({
+      name,
+      remoteVersion,
+      localVersion,
+      action,
+      destination: skillFile,
+      author: String(row.author ?? ""),
+      sourceAgent: String(row.source_agent ?? "")
+    });
+    if (action === "wrote")
+      summary.wrote++;
+    else if (action === "dryrun")
+      summary.dryrun++;
+    else
+      summary.skipped++;
+  }
+  return summary;
+}
+
+// dist/src/commands/skilify.js
+var STATE_DIR2 = join18(homedir8(), ".deeplake", "state", "skilify");
+function showStatus() {
+  const cfg = loadScopeConfig();
+  console.log(`scope:   ${cfg.scope}`);
+  console.log(`team:    ${cfg.team.length === 0 ? "(empty)" : cfg.team.join(", ")}`);
+  console.log(`install: ${cfg.install}  (${cfg.install === "global" ? "~/.claude/skills/" : "<project>/.claude/skills/"})`);
+  if (!existsSync15(STATE_DIR2)) {
+    console.log(`state: (no projects tracked yet)`);
+    return;
+  }
+  const files = readdirSync3(STATE_DIR2).filter((f) => f.endsWith(".json") && f !== "config.json");
+  if (files.length === 0) {
+    console.log(`state: (no projects tracked yet)`);
+    return;
+  }
+  console.log(`state: ${files.length} project(s) tracked`);
+  for (const f of files) {
+    try {
+      const s = JSON.parse(readFileSync12(join18(STATE_DIR2, f), "utf-8"));
+      const skills = s.skillsGenerated.length === 0 ? "none" : s.skillsGenerated.join(", ");
+      console.log(`  - ${s.project} (counter=${s.counter}, last=${s.lastDate ?? "never"}, skills=${skills})`);
+    } catch {
+    }
+  }
+}
+function setScope(scope) {
+  if (scope !== "me" && scope !== "team" && scope !== "org") {
+    console.error(`Invalid scope '${scope}'. Use one of: me, team, org`);
+    process.exit(1);
+  }
+  const cfg = loadScopeConfig();
+  saveScopeConfig({ ...cfg, scope });
+  console.log(`Scope set to '${scope}'.`);
+  if (scope === "team" && cfg.team.length === 0) {
+    console.log(`Note: team list is empty. Use 'hivemind skilify 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`);
+    process.exit(1);
+  }
+  const cfg = loadScopeConfig();
+  saveScopeConfig({ ...cfg, install: loc });
+  const path = loc === "global" ? join18(homedir8(), ".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) {
+  if (!name) {
+    console.error("Usage: hivemind skilify promote <skill-name>");
+    process.exit(1);
+  }
+  const projectPath = join18(cwd, ".claude", "skills", name);
+  const globalPath = join18(homedir8(), ".claude", "skills", name);
+  if (!existsSync15(join18(projectPath, "SKILL.md"))) {
+    console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
+    process.exit(1);
+  }
+  if (existsSync15(join18(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);
+  }
+  mkdirSync7(dirname2(globalPath), { recursive: true });
+  renameSync2(projectPath, globalPath);
+  console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
+}
+function teamAdd(name) {
+  if (!name) {
+    console.error("Usage: hivemind skilify team add <username>");
+    process.exit(1);
+  }
+  const cfg = loadScopeConfig();
+  if (cfg.team.includes(name)) {
+    console.log(`'${name}' is already in the team list.`);
+    return;
+  }
+  const next = [...cfg.team, name].sort();
+  saveScopeConfig({ ...cfg, team: next });
+  console.log(`Added '${name}' to team. Team is now: ${next.join(", ")}`);
+}
+function teamRemove(name) {
+  if (!name) {
+    console.error("Usage: hivemind skilify team remove <username>");
+    process.exit(1);
+  }
+  const cfg = loadScopeConfig();
+  if (!cfg.team.includes(name)) {
+    console.log(`'${name}' is not in the team list.`);
+    return;
+  }
+  const next = cfg.team.filter((n) => n !== name);
+  saveScopeConfig({ ...cfg, team: next });
+  console.log(`Removed '${name}' from team. Team is now: ${next.length === 0 ? "(empty)" : next.join(", ")}`);
+}
+function teamList() {
+  const cfg = loadScopeConfig();
+  if (cfg.team.length === 0) {
+    console.log(`(team list is empty)`);
+    return;
+  }
+  for (const n of cfg.team)
+    console.log(n);
+}
+function usage() {
+  console.log("Usage:");
+  console.log("  hivemind skilify                            show current scope, team, install, and per-project state");
+  console.log("  hivemind skilify scope <me|team|org>        set the mining scope");
+  console.log("  hivemind skilify install <project|global>   set where new skills are written");
+  console.log("  hivemind skilify promote <skill-name>       move a project skill to the global location");
+  console.log("  hivemind skilify team add <username>        add a username to the team list");
+  console.log("  hivemind skilify team remove <username>     remove a username from the team list");
+  console.log("  hivemind skilify team list                  list current team members");
+  console.log("  hivemind skilify pull [skill-name] [opts]   fetch skills from Deeplake to local FS");
+  console.log("    Options for pull:");
+  console.log("      --to <project|global>     destination (default: global)");
+  console.log("      --user <name>             only skills authored by this user");
+  console.log("      --users <a,b,c>           only skills authored by these users");
+  console.log("      --all-users               all authors (default \u2014 equivalent to no filter)");
+  console.log("      --dry-run                 show what would be written, don't touch disk");
+  console.log("      --force                   overwrite even when local version >= remote");
+  console.log("  hivemind skilify status                     show per-project state");
+}
+function takeFlagValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0)
+    return null;
+  const value = args[idx + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    console.error(`${flag} requires a value`);
+    process.exit(1);
+  }
+  args.splice(idx, 2);
+  return value;
+}
+function takeBooleanFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0)
+    return false;
+  args.splice(idx, 1);
+  return true;
+}
+async function pullSkills(args) {
+  const work = [...args];
+  const toRaw = takeFlagValue(work, "--to") ?? "global";
+  const userOne = takeFlagValue(work, "--user");
+  const usersMany = takeFlagValue(work, "--users");
+  const allUsers = takeBooleanFlag(work, "--all-users");
+  const dryRun = takeBooleanFlag(work, "--dry-run");
+  const force = takeBooleanFlag(work, "--force");
+  const skillName = work[0];
+  if (toRaw !== "project" && toRaw !== "global") {
+    console.error(`Invalid --to '${toRaw}'. Use 'project' or 'global'.`);
+    process.exit(1);
+  }
+  let users = [];
+  if (allUsers)
+    users = [];
+  else if (userOne)
+    users = [userOne];
+  else if (usersMany)
+    users = usersMany.split(",").map((s) => s.trim()).filter(Boolean);
+  const config = loadConfig();
+  if (!config) {
+    console.error("Not logged in. Run: hivemind login");
+    process.exit(1);
+  }
+  const api = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.skillsTableName);
+  const query = (sql) => api.query(sql);
+  let summary;
+  try {
+    summary = await runPull({
+      query,
+      tableName: config.skillsTableName,
+      install: toRaw,
+      cwd: toRaw === "project" ? process.cwd() : void 0,
+      users,
+      skillName,
+      dryRun,
+      force
+    });
+  } catch (e) {
+    console.error(`pull failed: ${e?.message ?? e}`);
+    process.exit(1);
+  }
+  const dest = toRaw === "global" ? join18(homedir8(), ".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" : ""}`);
+  console.log(`Scanned ${summary.scanned} remote skill(s).`);
+  for (const e of summary.entries) {
+    const tag = e.action === "wrote" ? "\u2713 wrote" : e.action === "dryrun" ? "\u2192 would write" : "\xB7 skipped";
+    const ver = e.localVersion === null ? `v${e.remoteVersion} (new)` : `v${e.localVersion} \u2192 v${e.remoteVersion}`;
+    console.log(`  ${tag.padEnd(15)} ${e.name.padEnd(40)} ${ver.padEnd(20)} (${e.author}/${e.sourceAgent})`);
+  }
+  console.log(`Result: ${summary.wrote} written, ${summary.dryrun} dry-run, ${summary.skipped} skipped.`);
+}
+function runSkilifyCommand(args) {
+  const sub = args[0];
+  if (!sub || sub === "status") {
+    showStatus();
+    return;
+  }
+  if (sub === "scope") {
+    setScope(args[1] ?? "");
+    return;
+  }
+  if (sub === "install") {
+    setInstall(args[1] ?? "");
+    return;
+  }
+  if (sub === "promote") {
+    promoteSkill(args[1] ?? "", process.cwd());
+    return;
+  }
+  if (sub === "pull") {
+    pullSkills(args.slice(1)).catch((e) => {
+      console.error(`pull error: ${e?.message ?? e}`);
+      process.exit(1);
+    });
+    return;
+  }
+  if (sub === "team") {
+    const action = args[1];
+    if (action === "add") {
+      teamAdd(args[2] ?? "");
+      return;
+    }
+    if (action === "remove") {
+      teamRemove(args[2] ?? "");
+      return;
+    }
+    if (action === "list") {
+      teamList();
+      return;
+    }
+    console.error("Usage: hivemind skilify team <add|remove|list> [name]");
+    process.exit(1);
+  }
+  if (sub === "--help" || sub === "-h" || sub === "help") {
+    usage();
+    return;
+  }
+  console.error(`Unknown skilify subcommand: ${sub}`);
+  usage();
+  process.exit(1);
+}
+if (process.argv[1] && process.argv[1].endsWith("skilify.js")) {
+  runSkilifyCommand(process.argv.slice(2));
+}
+
+// dist/src/cli/update.js
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync14, realpathSync } from "node:fs";
+import { dirname as dirname4, sep } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// dist/src/utils/version-check.js
+import { readFileSync as readFileSync13 } from "node:fs";
+import { dirname as dirname3, join as join19 } from "node:path";
+function isNewer(latest, current) {
+  const parse = (v) => v.split(".").map(Number);
+  const [la, lb, lc] = parse(latest);
+  const [ca, cb, cc] = parse(current);
+  return la > ca || la === ca && lb > cb || la === ca && lb === cb && lc > cc;
+}
+
+// dist/src/cli/update.js
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@deeplake/hivemind/latest";
+var PKG_NAME = "@deeplake/hivemind";
+function detectInstallKind(argv1) {
+  const realArgv1 = (() => {
+    try {
+      return realpathSync(argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url));
+    } catch {
+      return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
+    }
+  })();
+  let dir = dirname4(realArgv1);
+  let installDir = null;
+  for (let i = 0; i < 10; i++) {
+    const pkgPath = `${dir}${sep}package.json`;
+    try {
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+      if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
+        installDir = dir;
+        break;
+      }
+    } catch {
+    }
+    const parent = dirname4(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  installDir ??= dirname4(realArgv1);
+  if (realArgv1.includes(`${sep}_npx${sep}`) || realArgv1.includes(`${sep}.npx${sep}`)) {
+    return { kind: "npx", installDir };
+  }
+  if (realArgv1.includes(`${sep}node_modules${sep}@deeplake${sep}hivemind`) || realArgv1.includes(`${sep}node_modules${sep}hivemind`)) {
+    return { kind: "npm-global", installDir };
+  }
+  let gitDir = installDir;
+  for (let i = 0; i < 6; i++) {
+    if (existsSync16(`${gitDir}${sep}.git`)) {
+      return { kind: "local-dev", installDir };
+    }
+    const parent = dirname4(gitDir);
+    if (parent === gitDir)
+      break;
+    gitDir = parent;
+  }
+  return { kind: "unknown", installDir };
+}
+async function getLatestNpmVersion(timeoutMs = 5e3) {
+  try {
+    const res = await fetch(NPM_REGISTRY_URL, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok)
+      return null;
+    const meta = await res.json();
+    return meta.version ?? null;
+  } catch {
+    return null;
+  }
+}
+var defaultSpawn = (cmd, args) => {
+  execFileSync4(cmd, args, { stdio: "inherit" });
+};
+async function runUpdate(opts = {}) {
+  const current = opts.currentVersionOverride ?? getVersion();
+  const latest = opts.latestVersionOverride !== void 0 ? opts.latestVersionOverride : await getLatestNpmVersion();
+  if (!latest) {
+    warn(`Could not reach npm registry to check for updates.`);
+    warn(`Current version: ${current}`);
+    return 1;
+  }
+  if (!isNewer(latest, current)) {
+    log(`hivemind ${current} is up to date (npm latest: ${latest}).`);
+    return 0;
+  }
+  log(`Update available: ${current} \u2192 ${latest}`);
+  const detected = opts.installKindOverride ?? detectInstallKind();
+  const spawn = opts.spawn ?? defaultSpawn;
+  switch (detected.kind) {
+    case "npm-global": {
+      if (opts.dryRun) {
+        log(`(dry-run) Would run: npm install -g ${PKG_NAME}@latest`);
+        log(`(dry-run) Would re-run: hivemind install --skip-auth`);
+        return 0;
+      }
+      log(`Upgrading via npm\u2026`);
+      try {
+        spawn("npm", ["install", "-g", `${PKG_NAME}@latest`]);
+      } catch (e) {
+        warn(`npm install failed: ${e.message}`);
+        warn(`Try running it manually: npm install -g ${PKG_NAME}@latest`);
+        return 1;
+      }
+      log(``);
+      log(`Refreshing agent bundles\u2026`);
+      try {
+        spawn("hivemind", ["install", "--skip-auth"]);
+      } catch (e) {
+        warn(`Agent refresh failed: ${e.message}`);
+        warn(`Run manually: hivemind install`);
+        return 1;
+      }
+      log(``);
+      log(`Updated to ${latest}.`);
+      return 0;
+    }
+    case "npx": {
+      if (opts.dryRun) {
+        log(`(dry-run) Would print npx-pin instructions (no persistent install to upgrade).`);
+        return 0;
+      }
+      log(`You ran hivemind via npx, which does not have a persistent global install.`);
+      log(`To use the new version, re-run with the explicit version pin:`);
+      log(``);
+      log(`  npx ${PKG_NAME}@${latest} install`);
+      log(``);
+      log(`Or install globally so future updates are one command:`);
+      log(``);
+      log(`  npm install -g ${PKG_NAME}@latest`);
+      return 0;
+    }
+    case "local-dev": {
+      if (opts.dryRun) {
+        log(`(dry-run) Would refuse: running from a local dev checkout (${detected.installDir}).`);
+        return 0;
+      }
+      warn(`hivemind is running from a local development checkout (${detected.installDir}).`);
+      warn(`Update via your dev workflow (git pull + npm install + npm run build),`);
+      warn(`not via 'hivemind update'.`);
+      return 1;
+    }
+    case "unknown":
+    default: {
+      if (opts.dryRun) {
+        log(`(dry-run) Would refuse: install kind unknown (${detected.installDir}).`);
+        return 0;
+      }
+      warn(`Could not determine how hivemind was installed (path: ${detected.installDir}).`);
+      warn(`Update manually: npm install -g ${PKG_NAME}@latest`);
+      return 1;
+    }
+  }
+}
+
 // dist/src/cli/index.js
 var AUTH_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "whoami",
@@ -4229,10 +5419,14 @@ var USAGE = `
 hivemind \u2014 one brain for every agent on your team
 
 Usage:
-  hivemind install [--only <platforms>] [--skip-auth]
+  hivemind install   [--only <platforms>] [--skip-auth]
       Auto-detect assistants on this machine and install hivemind into each.
       --only takes a comma-separated list: ${allPlatformIds().join(",")}
 
+  hivemind uninstall [--only <platforms>]
+      Auto-detect installed assistants and remove hivemind from each.
+      --only takes the same list to scope the removal.
+
   hivemind claude  install | uninstall
   hivemind codex   install | uninstall
   hivemind claw    install | uninstall
@@ -4243,6 +5437,34 @@ Usage:
 
   hivemind login            Run device-flow login (open browser).
   hivemind status           Show which assistants are wired up.
+  hivemind update [--dry-run]
+      Check npm for a newer @deeplake/hivemind, upgrade the CLI, and refresh
+      every detected agent bundle. Single command for all agents.
+
+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.
+
+  Add --with-embeddings to "hivemind install" (or "hivemind <agent> install")
+  to run "embeddings install" automatically after installing the agent(s).
+
+Skill management (mine + share reusable Claude skills across the org):
+  hivemind skilify                         Show scope, team, install, and per-project state.
+  hivemind skilify pull [skill-name]       Sync skills from the org table to local FS.
+                                           Options: --user <email>, --users a,b,c,
+                                           --all-users, --to <project|global>,
+                                           --dry-run, --force.
+  hivemind skilify scope <me|team|org>     Set the sharing scope for newly mined skills.
+  hivemind skilify install <project|global>  Set where new skills are written.
+  hivemind skilify promote <name>          Move a project skill to the global location.
+  hivemind skilify team add <username>     Add a username to the team list.
+  hivemind skilify team remove <username>  Remove a username from the team list.
+  hivemind skilify team list               List current team members.
 
 Account / org / workspace:
   hivemind whoami                          Show current user, org, workspace.
@@ -4250,7 +5472,8 @@ Account / org / workspace:
   hivemind org list                        List organizations.
   hivemind org switch <name-or-id>         Switch active organization.
   hivemind workspaces                      List workspaces in current org.
-  hivemind workspace <id>                  Switch active workspace.
+  hivemind workspace list                  List workspaces (alias of 'workspaces').
+  hivemind workspace switch <name-or-id>   Switch active workspace.
   hivemind members                         List org members.
   hivemind invite <email> <ADMIN|WRITE|READ>  Invite a teammate.
   hivemind remove <user-id>                Remove a member.
@@ -4284,6 +5507,7 @@ function hasFlag(args, flag) {
 async function runInstallAll(args) {
   const only = parseOnly(args);
   const skipAuth = hasFlag(args, "--skip-auth");
+  const withEmbeddings = hasFlag(args, "--with-embeddings");
   const targets = only ?? detectPlatforms().map((p) => p.id);
   if (targets.length === 0) {
     log("No supported assistants detected.");
@@ -4302,6 +5526,10 @@ async function runInstallAll(args) {
   }
   for (const id of targets)
     runSingleInstall(id);
+  if (withEmbeddings) {
+    log("");
+    enableEmbeddings();
+  }
   await maybeShowOrgChoice();
   log("");
   log("Done. Restart each assistant to activate hooks.");
@@ -4383,6 +5611,31 @@ async function main() {
     runStatus();
     return;
   }
+  if (cmd === "update") {
+    const code = await runUpdate({ dryRun: hasFlag(args.slice(1), "--dry-run") });
+    process.exit(code);
+  }
+  if (cmd === "skilify") {
+    runSkilifyCommand(args.slice(1));
+    return;
+  }
+  if (cmd === "embeddings") {
+    const sub = args[1];
+    if (sub === "install" || sub === "enable") {
+      enableEmbeddings();
+      return;
+    }
+    if (sub === "uninstall" || sub === "disable") {
+      disableEmbeddings({ prune: hasFlag(args.slice(2), "--prune") });
+      return;
+    }
+    if (sub === "status") {
+      statusEmbeddings();
+      return;
+    }
+    warn("Usage: hivemind embeddings install | uninstall [--prune] | status");
+    process.exit(1);
+  }
   if (AUTH_SUBCOMMANDS.has(cmd)) {
     await runAuthCommand(args);
     return;
@@ -4390,12 +5643,16 @@ async function main() {
   const platformCmds = ["claude", "codex", "claw", "cursor", "hermes", "pi"];
   if (platformCmds.includes(cmd)) {
     const sub = args[1];
-    if (sub === "install")
+    if (sub === "install") {
       runSingleInstall(cmd);
-    else if (sub === "uninstall")
+      if (hasFlag(args.slice(2), "--with-embeddings")) {
+        log("");
+        enableEmbeddings();
+      }
+    } else if (sub === "uninstall")
       runSingleUninstall(cmd);
     else {
-      warn(`Usage: hivemind ${cmd} install|uninstall`);
+      warn(`Usage: hivemind ${cmd} install [--with-embeddings] | uninstall`);
       process.exit(1);
     }
     return;