@deeplake/hivemind 0.7.78 → 0.7.80

package/.claude-plugin/marketplace.json

@@ -6,18 +6,18 @@
   },
   "metadata": {
     "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
-    "version": "0.7.78"
+    "version": "0.7.80"
   },
   "plugins": [
     {
       "name": "hivemind",
       "description": "Persistent shared memory powered by Deeplake — captures all session activity and provides cross-session, cross-agent memory search",
-      "version": "0.7.78",
+      "version": "0.7.80",
       "source": {
         "source": "git-subdir",
         "url": "https://github.com/activeloopai/hivemind.git",
         "path": "claude-code",
-        "sha": "64e787b7d16918e72a53395fd79edc36836a2bd2"
+        "sha": "491ff3fe01c8ffe102dd4ed88dc67b645870c8af"
       },
       "homepage": "https://github.com/activeloopai/hivemind"
     }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "hivemind",
   "description": "Cloud-backed persistent memory powered by Deeplake — read, write, and share memory across Claude Code sessions and agents",
-  "version": "0.7.78",
+  "version": "0.7.80",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/bundle/cli.js

@@ -3622,6 +3622,7 @@ var WIKI_WORKER_DIR = join10(PI_AGENT_DIR, "hivemind");
 var WIKI_WORKER_PATH = join10(WIKI_WORKER_DIR, "wiki-worker.js");
 var SKILLIFY_WORKER_PATH = join10(WIKI_WORKER_DIR, "skillify-worker.js");
 var AUTOPULL_WORKER_PATH = join10(WIKI_WORKER_DIR, "autopull-worker.js");
+var SKILLOPT_WORKER_PATH = join10(WIKI_WORKER_DIR, "skillopt-worker.js");
 var HIVEMIND_BLOCK_START = "<!-- BEGIN hivemind-memory -->";
 var HIVEMIND_BLOCK_END = "<!-- END hivemind-memory -->";
 var HIVEMIND_BLOCK_BODY = `${HIVEMIND_BLOCK_START}
@@ -3716,6 +3717,11 @@ function installPi() {
     ensureDir(WIKI_WORKER_DIR);
     copyFileSync2(srcAutopullWorker, AUTOPULL_WORKER_PATH);
   }
+  const srcSkilloptWorker = join10(pkgRoot(), "pi", "bundle", "skillopt-worker.js");
+  if (existsSync9(srcSkilloptWorker)) {
+    ensureDir(WIKI_WORKER_DIR);
+    copyFileSync2(srcSkilloptWorker, SKILLOPT_WORKER_PATH);
+  }
   ensureDir(VERSION_DIR);
   writeVersionStamp(VERSION_DIR, getVersion());
   log(`  pi             AGENTS.md updated -> ${AGENTS_MD}`);
@@ -3729,6 +3735,9 @@ function installPi() {
   if (existsSync9(AUTOPULL_WORKER_PATH)) {
     log(`  pi             autopull-worker installed -> ${AUTOPULL_WORKER_PATH}`);
   }
+  if (existsSync9(SKILLOPT_WORKER_PATH)) {
+    log(`  pi             skillopt-worker installed -> ${SKILLOPT_WORKER_PATH}`);
+  }
 }
 function uninstallPi() {
   if (existsSync9(LEGACY_SKILL_DIR)) {

package/codex/bundle/capture.js

@@ -367,38 +367,38 @@ function readQueue() {
     return { queue: [] };
   }
 }
-function _isQueuePathInsideHome(path, home) {
-  const r = resolve(path);
+function _isQueuePathInsideHome(path2, home) {
+  const r = resolve(path2);
   const h = resolve(home);
   return r.startsWith(h + "/") || r === h;
 }
 function writeQueue(q) {
-  const path = queuePath();
+  const path2 = queuePath();
   const home = resolve(homedir3());
-  if (!_isQueuePathInsideHome(path, home)) {
-    throw new Error(`notifications-queue write blocked: ${path} is outside ${home}`);
+  if (!_isQueuePathInsideHome(path2, home)) {
+    throw new Error(`notifications-queue write blocked: ${path2} is outside ${home}`);
   }
   mkdirSync(join3(home, ".deeplake"), { recursive: true, mode: 448 });
-  const tmp = `${path}.${process.pid}.tmp`;
+  const tmp = `${path2}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify(q, null, 2), { mode: 384 });
-  renameSync(tmp, path);
+  renameSync(tmp, path2);
 }
 async function withQueueLock(fn) {
-  const path = lockPath();
+  const path2 = lockPath();
   mkdirSync(join3(homedir3(), ".deeplake"), { recursive: true, mode: 448 });
   let fd = null;
   for (let attempt = 0; attempt < LOCK_RETRY_MAX; attempt++) {
     try {
-      fd = openSync(path, "wx", 384);
+      fd = openSync(path2, "wx", 384);
       break;
     } catch (e) {
       const code = e.code;
       if (code !== "EEXIST")
         throw e;
       try {
-        const age = Date.now() - statSync(path).mtimeMs;
+        const age = Date.now() - statSync(path2).mtimeMs;
         if (age > LOCK_STALE_MS) {
-          unlinkSync(path);
+          unlinkSync(path2);
           continue;
         }
       } catch {
@@ -419,7 +419,7 @@ async function withQueueLock(fn) {
     } catch {
     }
     try {
-      unlinkSync(path);
+      unlinkSync(path2);
     } catch {
     }
   }
@@ -695,9 +695,9 @@ var DeeplakeApi = class {
     }
   }
   /** Update specific columns on a row by path. */
-  async updateColumns(path, columns) {
+  async updateColumns(path2, columns) {
     const setClauses = Object.entries(columns).map(([col, val]) => typeof val === "number" ? `${col} = ${val}` : `${col} = '${sqlStr(String(val))}'`).join(", ");
-    await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(path)}'`);
+    await this.query(`UPDATE "${this.tableName}" SET ${setClauses} WHERE path = '${sqlStr(path2)}'`);
   }
   // ── Convenience ─────────────────────────────────────────────────────────────
   /** Create a BM25 search index on a column. */
@@ -1403,13 +1403,13 @@ var _migrated = false;
 function readUserConfig() {
   if (_cache !== null)
     return _cache;
-  const path = _configPath();
-  if (!existsSync4(path)) {
+  const path2 = _configPath();
+  if (!existsSync4(path2)) {
     _cache = {};
     return _cache;
   }
   try {
-    const raw = readFileSync6(path, "utf-8");
+    const raw = readFileSync6(path2, "utf-8");
     const parsed = JSON.parse(raw);
     _cache = isPlainObject(parsed) ? parsed : {};
   } catch {
@@ -1420,13 +1420,13 @@ function readUserConfig() {
 function writeUserConfig(patch) {
   const current = readUserConfig();
   const merged = deepMerge(current, patch);
-  const path = _configPath();
-  const dir = dirname(path);
+  const path2 = _configPath();
+  const dir = dirname(path2);
   if (!existsSync4(dir))
     mkdirSync4(dir, { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}`;
+  const tmp = `${path2}.tmp.${process.pid}`;
   writeFileSync4(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-  renameSync2(tmp, path);
+  renameSync2(tmp, path2);
   _cache = merged;
   return merged;
 }
@@ -1571,8 +1571,8 @@ function createSymlinkAtomic(target, link) {
 }
 
 // dist/src/hooks/codex/capture.js
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname5, join as join14 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { dirname as dirname7, join as join17 } from "node:path";
 
 // dist/src/hooks/summary-state.js
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, writeSync as writeSync2, mkdirSync as mkdirSync6, renameSync as renameSync4, existsSync as existsSync6, unlinkSync as unlinkSync4, openSync as openSync3, closeSync as closeSync3, statSync as statSync3 } from "node:fs";
@@ -1719,13 +1719,13 @@ import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
 import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync2 } from "node:fs";
 import { join as join11 } from "node:path";
 function makeWikiLogger(hooksDir, filename = "deeplake-wiki.log") {
-  const path = join11(hooksDir, filename);
+  const path2 = join11(hooksDir, filename);
   return {
-    path,
+    path: path2,
     log(msg) {
       try {
         mkdirSync7(hooksDir, { recursive: true });
-        appendFileSync2(path, `[${utcTimestamp()}] ${msg}
+        appendFileSync2(path2, `[${utcTimestamp()}] ${msg}
 `);
       } catch {
       }
@@ -1778,10 +1778,10 @@ function getInstalledVersion(bundleDir, pluginManifestDir) {
 // dist/src/utils/spawn-detached.js
 import { spawn as nodeSpawn } from "node:child_process";
 function spawnDetachedNodeWorker(workerPath, args = [], deps = {}) {
-  const spawn2 = deps.spawn ?? nodeSpawn;
+  const spawn3 = deps.spawn ?? nodeSpawn;
   const execPath = deps.execPath ?? process.execPath;
   try {
-    const child = spawn2(execPath, [workerPath, ...args], {
+    const child = spawn3(execPath, [workerPath, ...args], {
       detached: true,
       stdio: ["ignore", "ignore", "ignore"],
       // Suppress the transient console window Windows would otherwise pop for
@@ -1892,12 +1892,144 @@ function bundleDirFromImportMeta(importMetaUrl) {
   return dirname4(fileURLToPath(importMetaUrl));
 }
 
+// dist/src/skillify/skillopt-trigger.js
+import { spawn as spawn2 } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// dist/src/skillify/state-dir.js
+import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
+function getStateDir() {
+  const override = process.env.HIVEMIND_STATE_DIR?.trim();
+  return override && override.length > 0 ? override : join14(homedir11(), ".deeplake", "state", "skillify");
+}
+
+// dist/src/skillify/manifest.js
+import { existsSync as existsSync8, lstatSync as lstatSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync9, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname6, join as join16 } from "node:path";
+
+// dist/src/skillify/legacy-migration.js
+import { existsSync as existsSync7, renameSync as renameSync5 } from "node:fs";
+import { dirname as dirname5, join as join15 } from "node:path";
+
+// dist/src/skillify/skillopt-env.js
+var SKILLOPT_ENV = {
+  /** User-set kill switch: "1" disables the whole trigger. */
+  DISABLED: "HIVEMIND_SKILLOPT_DISABLED",
+  /** Recursion guard the trigger sets on the spawned worker so the worker can't re-arm. */
+  WORKER: "HIVEMIND_SKILLOPT_WORKER",
+  /** Worker inputs, handed trigger → worker via the child env. */
+  SESSION: "HIVEMIND_SKILLOPT_SESSION",
+  SKILL: "HIVEMIND_SKILLOPT_SKILL",
+  REACTION: "HIVEMIND_SKILLOPT_REACTION",
+  TOOL_USE_ID: "HIVEMIND_SKILLOPT_TOOL_USE_ID",
+  /** Which agent's CLI runs the judge/proposer (claude_code/codex/hermes/cursor/pi). */
+  AGENT: "HIVEMIND_SKILLOPT_AGENT",
+  /** K-message judgment-window size override. */
+  JUDGE_WINDOW: "HIVEMIND_SKILLOPT_JUDGE_WINDOW"
+};
+
+// dist/src/skillify/skillopt-trigger.js
+var log5 = (m) => log("skillopt-trigger", m);
+function defaultHasCreds() {
+  try {
+    return Boolean(loadConfig()?.token);
+  } catch {
+    return false;
+  }
+}
+var MAX_REACTION = 8e3;
+function pendingFile(sessionId) {
+  const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 200);
+  return path.join(getStateDir(), "skillopt", "pending", `${safe}.json`);
+}
+var fileStore = {
+  load(sessionId) {
+    try {
+      return JSON.parse(fs.readFileSync(pendingFile(sessionId), "utf8"));
+    } catch {
+      return null;
+    }
+  },
+  save(sessionId, p) {
+    try {
+      const f = pendingFile(sessionId);
+      if (p === null) {
+        try {
+          fs.unlinkSync(f);
+        } catch {
+        }
+        return;
+      }
+      fs.mkdirSync(path.dirname(f), { recursive: true });
+      const tmp = `${f}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify(p));
+      fs.renameSync(tmp, f);
+    } catch {
+    }
+  }
+};
+function runEventTrigger(sessionId, reaction, opts = {}) {
+  const deps = opts.deps ?? {};
+  const env = deps.env ?? process.env;
+  if (env[SKILLOPT_ENV.DISABLED] === "1")
+    return { fired: false, reason: "disabled" };
+  if (env[SKILLOPT_ENV.WORKER] === "1")
+    return { fired: false, reason: "in-worker" };
+  if (!sessionId)
+    return { fired: false, reason: "no-skill" };
+  const store = deps.store ?? fileStore;
+  const p = store.load(sessionId);
+  if (!p)
+    return { fired: false, reason: "no-skill" };
+  if (!(deps.canFire ?? defaultHasCreds)())
+    return { fired: false, reason: "no-creds" };
+  store.save(sessionId, p.budget - 1 <= 0 ? null : { ...p, budget: p.budget - 1 });
+  (deps.spawnWorker ?? spawnWorker)(sessionId, p.skill, reaction ?? "", p.toolUseId, opts.agent);
+  return { fired: true, reason: "spawned" };
+}
+function spawnWorker(sessionId, skill, reaction, toolUseId, agent) {
+  try {
+    const here = path.dirname(fileURLToPath2(import.meta.url));
+    const entry = path.join(here, "skillopt-worker.js");
+    const child = spawn2(process.execPath, [entry], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        [SKILLOPT_ENV.WORKER]: "1",
+        [SKILLOPT_ENV.SESSION]: sessionId,
+        [SKILLOPT_ENV.SKILL]: skill,
+        [SKILLOPT_ENV.REACTION]: (reaction ?? "").slice(0, MAX_REACTION),
+        ...toolUseId ? { [SKILLOPT_ENV.TOOL_USE_ID]: toolUseId } : {},
+        ...agent ? { [SKILLOPT_ENV.AGENT]: agent } : {}
+      }
+    });
+    child.unref();
+    log5(`spawned skillopt worker for ${skill} in ${sessionId}${agent ? ` (agent=${agent})` : ""}`);
+  } catch (e) {
+    log5(`spawn failed (swallowed): ${e?.message ?? e}`);
+  }
+}
+
+// dist/src/hooks/shared/skillopt-hook.js
+function reactSkillOpt(sessionId, prompt, agent) {
+  try {
+    if (prompt === void 0 || prompt.trim() === "" || process.env.HIVEMIND_WIKI_WORKER === "1")
+      return;
+    runEventTrigger(sessionId, prompt, { agent });
+  } catch {
+  }
+}
+
 // dist/src/hooks/codex/capture.js
-var log5 = (msg) => log("codex-capture", msg);
+var log6 = (msg) => log("codex-capture", msg);
 function resolveEmbedDaemonPath() {
-  return join14(dirname5(fileURLToPath2(import.meta.url)), "embeddings", "embed-daemon.js");
+  return join17(dirname7(fileURLToPath3(import.meta.url)), "embeddings", "embed-daemon.js");
 }
-var __bundleDir = dirname5(fileURLToPath2(import.meta.url));
+var __bundleDir = dirname7(fileURLToPath3(import.meta.url));
 var PLUGIN_VERSION = getInstalledVersion(__bundleDir, ".codex-plugin") ?? "";
 if (!embeddingsDisabled()) {
   try {
@@ -1912,7 +2044,7 @@ async function main() {
   const input = await readStdin();
   const config = loadConfig();
   if (!config) {
-    log5("no config");
+    log6("no config");
     return;
   }
   const sessionsTable = config.sessionsTableName;
@@ -1929,7 +2061,7 @@ async function main() {
   };
   let entry;
   if (input.hook_event_name === "UserPromptSubmit" && input.prompt !== void 0) {
-    log5(`user session=${input.session_id}`);
+    log6(`user session=${input.session_id}`);
     entry = {
       id: crypto.randomUUID(),
       ...meta,
@@ -1937,7 +2069,7 @@ async function main() {
       content: input.prompt
     };
   } else if (input.hook_event_name === "PostToolUse" && input.tool_name !== void 0) {
-    log5(`tool=${input.tool_name} session=${input.session_id}`);
+    log6(`tool=${input.tool_name} session=${input.session_id}`);
     entry = {
       id: crypto.randomUUID(),
       ...meta,
@@ -1948,12 +2080,12 @@ async function main() {
       tool_response: JSON.stringify(input.tool_response)
     };
   } else {
-    log5(`unknown event: ${input.hook_event_name}, skipping`);
+    log6(`unknown event: ${input.hook_event_name}, skipping`);
     return;
   }
   const sessionPath = buildSessionPath(config, input.session_id);
   const line = JSON.stringify(entry);
-  log5(`writing to ${sessionPath}`);
+  log6(`writing to ${sessionPath}`);
   const projectName = projectNameFromCwd(input.cwd);
   const filename = sessionPath.split("/").pop() ?? "";
   const jsonForSql = line.replace(/'/g, "''");
@@ -1964,14 +2096,15 @@ async function main() {
     await api.query(insertSql);
   } catch (e) {
     if (e.message?.includes("permission denied") || e.message?.includes("does not exist")) {
-      log5("table missing, creating and retrying");
+      log6("table missing, creating and retrying");
       await api.ensureSessionsTable(sessionsTable);
       await api.query(insertSql);
     } else {
       throw e;
     }
   }
-  log5("capture ok");
+  log6("capture ok");
+  reactSkillOpt(input.session_id, input.prompt, "codex");
   maybeTriggerPeriodicSummary(input.session_id, input.cwd ?? "", config);
 }
 function maybeTriggerPeriodicSummary(sessionId, cwd, config) {
@@ -1983,7 +2116,7 @@ function maybeTriggerPeriodicSummary(sessionId, cwd, config) {
     if (!shouldTrigger(state, cfg))
       return;
     if (!tryAcquireLock(sessionId)) {
-      log5(`periodic trigger suppressed (lock held) session=${sessionId}`);
+      log6(`periodic trigger suppressed (lock held) session=${sessionId}`);
       return;
     }
     wikiLog(`Periodic: threshold hit (total=${state.totalCount}, since=${state.totalCount - state.lastSummaryCount}, N=${cfg.everyNMessages}, hours=${cfg.everyHours})`);
@@ -1996,19 +2129,19 @@ function maybeTriggerPeriodicSummary(sessionId, cwd, config) {
         reason: "Periodic"
       });
     } catch (e) {
-      log5(`periodic spawn failed: ${e.message}`);
+      log6(`periodic spawn failed: ${e.message}`);
       try {
         releaseLock(sessionId);
       } catch (releaseErr) {
-        log5(`releaseLock after periodic spawn failure also failed: ${releaseErr.message}`);
+        log6(`releaseLock after periodic spawn failure also failed: ${releaseErr.message}`);
       }
       throw e;
     }
   } catch (e) {
-    log5(`periodic trigger error: ${e.message}`);
+    log6(`periodic trigger error: ${e.message}`);
   }
 }
 main().catch((e) => {
-  log5(`fatal: ${e.message}`);
+  log6(`fatal: ${e.message}`);
   process.exit(0);
 });