@deeplake/hivemind 0.7.79 → 0.7.81

package/codex/bundle/capture.js

@@ -17,7 +17,7 @@ __export(index_marker_store_exports, {
   hasFreshIndexMarker: () => hasFreshIndexMarker,
   writeIndexMarker: () => writeIndexMarker
 });
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join5 } from "node:path";
 import { tmpdir } from "node:os";
 function getIndexMarkerDir() {
@@ -41,7 +41,7 @@ function hasFreshIndexMarker(markerPath) {
   }
 }
 function writeIndexMarker(markerPath) {
-  mkdirSync3(getIndexMarkerDir(), { recursive: true });
+  mkdirSync4(getIndexMarkerDir(), { recursive: true });
   writeFileSync3(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
 }
 var INDEX_MARKER_TTL_MS;
@@ -120,8 +120,8 @@ function loadConfig() {
 import { randomUUID } from "node:crypto";
 
 // dist/src/utils/debug.js
-import { appendFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 var LOG = join2(homedir2(), ".deeplake", "hook-debug.log");
 function isDebug() {
@@ -133,8 +133,12 @@ function utcTimestamp(d = /* @__PURE__ */ new Date()) {
 function log(tag, msg) {
   if (!isDebug())
     return;
-  appendFileSync(LOG, `${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${msg}
+  try {
+    mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${msg}
 `);
+  } catch {
+  }
 }
 
 // dist/src/utils/sql.js
@@ -340,7 +344,7 @@ async function healMissingColumns(args) {
 }
 
 // dist/src/notifications/queue.js
-import { readFileSync as readFileSync2, writeFileSync, renameSync, mkdirSync, openSync, closeSync, unlinkSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync, renameSync, mkdirSync as mkdirSync2, openSync, closeSync, unlinkSync, statSync } from "node:fs";
 import { join as join3, resolve } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -367,38 +371,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`;
+  mkdirSync2(join3(home, ".deeplake"), { recursive: true, mode: 448 });
+  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();
-  mkdirSync(join3(homedir3(), ".deeplake"), { recursive: true, mode: 448 });
+  const path2 = lockPath();
+  mkdirSync2(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 +423,7 @@ async function withQueueLock(fn) {
     } catch {
     }
     try {
-      unlinkSync(path);
+      unlinkSync(path2);
     } catch {
     }
   }
@@ -441,7 +445,7 @@ async function enqueueNotification(n) {
 }
 
 // dist/src/commands/auth-creds.js
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2 } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { join as join4 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function configDir() {
@@ -695,9 +699,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. */
@@ -1394,22 +1398,22 @@ import { join as join8 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // dist/src/user-config.js
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname, join as join7 } from "node:path";
+import { dirname as dirname2, join as join7 } from "node:path";
 var _configPath = () => process.env.HIVEMIND_CONFIG_PATH ?? join7(homedir6(), ".deeplake", "config.json");
 var _cache = null;
 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 +1424,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 = dirname2(path2);
   if (!existsSync4(dir))
-    mkdirSync4(dir, { recursive: true });
-  const tmp = `${path}.tmp.${process.pid}`;
+    mkdirSync5(dir, { recursive: true });
+  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;
 }
@@ -1506,15 +1510,15 @@ function embeddingsDisabled() {
 }
 
 // dist/src/embeddings/self-heal.js
-import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync5, readlinkSync, renameSync as renameSync3, rmSync, symlinkSync, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync6, readlinkSync, renameSync as renameSync3, rmSync, symlinkSync, statSync as statSync2 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { basename as basename2, dirname as dirname2, join as join9 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join9 } from "node:path";
 function ensurePluginNodeModulesLink(opts) {
   if (basename2(opts.bundleDir) !== "bundle") {
     return { kind: "not-bundle-layout", bundleDir: opts.bundleDir };
   }
   const target = opts.sharedNodeModules ?? join9(homedir8(), ".hivemind", "embed-deps", "node_modules");
-  const pluginDir = dirname2(opts.bundleDir);
+  const pluginDir = dirname3(opts.bundleDir);
   const link = join9(pluginDir, "node_modules");
   if (!existsSync5(target)) {
     return { kind: "shared-deps-missing", target };
@@ -1554,9 +1558,9 @@ function ensurePluginNodeModulesLink(opts) {
 }
 function createSymlinkAtomic(target, link) {
   try {
-    const parent = dirname2(link);
+    const parent = dirname3(link);
     if (!existsSync5(parent))
-      mkdirSync5(parent, { recursive: true });
+      mkdirSync6(parent, { recursive: true });
     const tmp = `${link}.tmp.${process.pid}`;
     try {
       rmSync(tmp, { force: true });
@@ -1571,11 +1575,11 @@ 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 dirname8, join as join18 } 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";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, writeSync as writeSync2, mkdirSync as mkdirSync7, renameSync as renameSync4, existsSync as existsSync6, unlinkSync as unlinkSync4, openSync as openSync3, closeSync as closeSync3, statSync as statSync3 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { join as join10 } from "node:path";
 var dlog = (msg) => log("summary-state", msg);
@@ -1598,14 +1602,14 @@ function readState(sessionId) {
   }
 }
 function writeState(sessionId, state) {
-  mkdirSync6(STATE_DIR, { recursive: true });
+  mkdirSync7(STATE_DIR, { recursive: true });
   const p = statePath(sessionId);
   const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync5(tmp, JSON.stringify(state));
   renameSync4(tmp, p);
 }
 function withRmwLock(sessionId, fn) {
-  mkdirSync6(STATE_DIR, { recursive: true });
+  mkdirSync7(STATE_DIR, { recursive: true });
   const rmwLock = statePath(sessionId) + ".rmw";
   const deadline = Date.now() + 2e3;
   let fd = null;
@@ -1667,7 +1671,7 @@ function shouldTrigger(state, cfg, now = Date.now()) {
   return false;
 }
 function tryAcquireLock(sessionId, maxAgeMs = 10 * 60 * 1e3) {
-  mkdirSync6(STATE_DIR, { recursive: true });
+  mkdirSync7(STATE_DIR, { recursive: true });
   const p = lockPath2(sessionId);
   if (existsSync6(p)) {
     try {
@@ -1711,21 +1715,21 @@ function releaseLock(sessionId) {
 // dist/src/hooks/codex/spawn-wiki-worker.js
 import { execSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname4, join as join13 } from "node:path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname5, join as join13 } from "node:path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync9 } from "node:fs";
 import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
 
 // dist/src/utils/wiki-log.js
-import { mkdirSync as mkdirSync7, appendFileSync as appendFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync8, 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}
+        mkdirSync8(hooksDir, { recursive: true });
+        appendFileSync2(path2, `[${utcTimestamp()}] ${msg}
 `);
       } catch {
       }
@@ -1735,7 +1739,7 @@ function makeWikiLogger(hooksDir, filename = "deeplake-wiki.log") {
 
 // dist/src/utils/version-check.js
 import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname3, join as join12 } from "node:path";
+import { dirname as dirname4, join as join12 } from "node:path";
 function getInstalledVersion(bundleDir, pluginManifestDir) {
   try {
     const pluginJson = join12(bundleDir, "..", pluginManifestDir, "plugin.json");
@@ -1767,7 +1771,7 @@ function getInstalledVersion(bundleDir, pluginManifestDir) {
         return pkg.version;
     } catch {
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -1778,10 +1782,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
@@ -1863,7 +1867,7 @@ function spawnCodexWikiWorker(opts) {
   const { config, sessionId, cwd, bundleDir, reason } = opts;
   const projectName = projectNameFromCwd(cwd);
   const tmpDir = join13(tmpdir2(), `deeplake-wiki-${sessionId}-${Date.now()}`);
-  mkdirSync8(tmpDir, { recursive: true });
+  mkdirSync9(tmpDir, { recursive: true });
   const pluginVersion = getInstalledVersion(bundleDir, ".codex-plugin") ?? "";
   const configFile = join13(tmpDir, "config.json");
   writeFileSync6(configFile, JSON.stringify({
@@ -1889,15 +1893,166 @@ function spawnCodexWikiWorker(opts) {
   wikiLog(`${reason}: spawned summary worker for ${sessionId}`);
 }
 function bundleDirFromImportMeta(importMetaUrl) {
-  return dirname4(fileURLToPath(importMetaUrl));
+  return dirname5(fileURLToPath(importMetaUrl));
+}
+
+// dist/src/utils/plugin-state.js
+import { readFileSync as readFileSync9 } from "node:fs";
+import { join as join14 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+var PLUGIN_ID = "hivemind@hivemind";
+function isHivemindPluginEnabled() {
+  try {
+    const settingsPath = join14(homedir11(), ".claude", "settings.json");
+    const settings = JSON.parse(readFileSync9(settingsPath, "utf-8"));
+    const enabledPlugins = settings?.enabledPlugins;
+    if (enabledPlugins && typeof enabledPlugins === "object" && PLUGIN_ID in enabledPlugins) {
+      return enabledPlugins[PLUGIN_ID] !== false;
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+// 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 homedir12 } from "node:os";
+import { join as join15 } from "node:path";
+function getStateDir() {
+  const override = process.env.HIVEMIND_STATE_DIR?.trim();
+  return override && override.length > 0 ? override : join15(homedir12(), ".deeplake", "state", "skillify");
+}
+
+// dist/src/skillify/manifest.js
+import { existsSync as existsSync8, lstatSync as lstatSync2, mkdirSync as mkdirSync10, readFileSync as readFileSync10, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname7, join as join17 } from "node:path";
+
+// dist/src/skillify/legacy-migration.js
+import { existsSync as existsSync7, renameSync as renameSync5 } from "node:fs";
+import { dirname as dirname6, join as join16 } 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 join18(dirname8(fileURLToPath3(import.meta.url)), "embeddings", "embed-daemon.js");
 }
-var __bundleDir = dirname5(fileURLToPath2(import.meta.url));
+var __bundleDir = dirname8(fileURLToPath3(import.meta.url));
 var PLUGIN_VERSION = getInstalledVersion(__bundleDir, ".codex-plugin") ?? "";
 if (!embeddingsDisabled()) {
   try {
@@ -1909,10 +2064,14 @@ var CAPTURE = process.env.HIVEMIND_CAPTURE !== "false";
 async function main() {
   if (!CAPTURE)
     return;
+  if (!isHivemindPluginEnabled()) {
+    log6("plugin disabled, skipping capture");
+    return;
+  }
   const input = await readStdin();
   const config = loadConfig();
   if (!config) {
-    log5("no config");
+    log6("no config");
     return;
   }
   const sessionsTable = config.sessionsTableName;
@@ -1929,7 +2088,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 +2096,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 +2107,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 +2123,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 +2143,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 +2156,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);
 });

package/codex/bundle/commands/auth-login.js

@@ -17,7 +17,7 @@ __export(index_marker_store_exports, {
   hasFreshIndexMarker: () => hasFreshIndexMarker,
   writeIndexMarker: () => writeIndexMarker
 });
-import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join6 } from "node:path";
 import { tmpdir } from "node:os";
 function getIndexMarkerDir() {
@@ -41,7 +41,7 @@ function hasFreshIndexMarker(markerPath) {
   }
 }
 function writeIndexMarker(markerPath) {
-  mkdirSync4(getIndexMarkerDir(), { recursive: true });
+  mkdirSync5(getIndexMarkerDir(), { recursive: true });
   writeFileSync4(markerPath, JSON.stringify({ updatedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
 }
 var INDEX_MARKER_TTL_MS;
@@ -413,8 +413,8 @@ function loadConfig() {
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/src/utils/debug.js
-import { appendFileSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname, join as join4 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 var LOG = join4(homedir4(), ".deeplake", "hook-debug.log");
 function isDebug() {
@@ -423,8 +423,12 @@ function isDebug() {
 function log(tag, msg) {
   if (!isDebug())
     return;
-  appendFileSync(LOG, `${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${msg}
+  try {
+    mkdirSync3(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${(/* @__PURE__ */ new Date()).toISOString()} [${tag}] ${msg}
 `);
+  } catch {
+  }
 }
 
 // dist/src/utils/sql.js
@@ -621,7 +625,7 @@ async function healMissingColumns(args) {
 }
 
 // dist/src/notifications/queue.js
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync, mkdirSync as mkdirSync3, openSync, closeSync, unlinkSync as unlinkSync2, statSync } from "node:fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync, mkdirSync as mkdirSync4, openSync, closeSync, unlinkSync as unlinkSync2, statSync } from "node:fs";
 import { join as join5, resolve } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -659,14 +663,14 @@ function writeQueue(q) {
   if (!_isQueuePathInsideHome(path, home)) {
     throw new Error(`notifications-queue write blocked: ${path} is outside ${home}`);
   }
-  mkdirSync3(join5(home, ".deeplake"), { recursive: true, mode: 448 });
+  mkdirSync4(join5(home, ".deeplake"), { recursive: true, mode: 448 });
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync3(tmp, JSON.stringify(q, null, 2), { mode: 384 });
   renameSync(tmp, path);
 }
 async function withQueueLock(fn) {
   const path = lockPath();
-  mkdirSync3(join5(homedir5(), ".deeplake"), { recursive: true, mode: 448 });
+  mkdirSync4(join5(homedir5(), ".deeplake"), { recursive: true, mode: 448 });
   let fd = null;
   for (let attempt = 0; attempt < LOCK_RETRY_MAX; attempt++) {
     try {
@@ -1241,8 +1245,8 @@ var DeeplakeApi = class {
 };
 
 // dist/src/cli/util.js
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5, cpSync, symlinkSync, unlinkSync as unlinkSync3, lstatSync } from "node:fs";
-import { join as join7, dirname } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, cpSync, symlinkSync, unlinkSync as unlinkSync3, lstatSync } from "node:fs";
+import { join as join7, dirname as dirname2 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";