@deeplake/hivemind 0.7.79 → 0.7.81

package/codex/bundle/pre-tool-use.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;
@@ -52,6 +52,11 @@ var init_index_marker_store = __esm({
   }
 });
 
+// dist/src/hooks/codex/pre-tool-use.js
+import { join as join19, dirname as dirname10 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { spawnSync } from "node:child_process";
+
 // dist/src/utils/stdin.js
 function readStdin() {
   return new Promise((resolve4, reject) => {
@@ -120,8 +125,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() {
@@ -130,8 +135,12 @@ function isDebug() {
 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 +349,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 +376,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 +428,7 @@ async function withQueueLock(fn) {
     } catch {
     }
     try {
-      unlinkSync(path);
+      unlinkSync(path2);
     } catch {
     }
   }
@@ -441,7 +450,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 +704,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. */
@@ -1129,8 +1138,8 @@ function formatToolCall(obj) {
 input: ${formatToolInput(obj?.tool_input)}
 response: ${formatToolResponse(obj?.tool_response, obj?.tool_input, obj?.tool_name)}`;
 }
-function normalizeContent(path, raw) {
-  if (!path.includes("/sessions/"))
+function normalizeContent(path2, raw) {
+  if (!path2.includes("/sessions/"))
     return raw;
   if (!raw || raw[0] !== "{")
     return raw;
@@ -1848,22 +1857,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 {
@@ -1874,13 +1883,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;
 }
@@ -1961,11 +1970,11 @@ function embeddingsDisabled() {
 
 // dist/src/hooks/grep-direct.js
 import { fileURLToPath } from "node:url";
-import { dirname as dirname2, join as join9 } from "node:path";
+import { dirname as dirname3, join as join9 } from "node:path";
 var SEMANTIC_ENABLED = process.env.HIVEMIND_SEMANTIC_SEARCH !== "false" && !embeddingsDisabled();
 var SEMANTIC_TIMEOUT_MS = Number(process.env.HIVEMIND_SEMANTIC_EMBED_TIMEOUT_MS ?? "500");
 function resolveDaemonPath() {
-  return join9(dirname2(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
+  return join9(dirname3(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
 }
 var sharedEmbedClient = null;
 function getEmbedClient() {
@@ -2318,13 +2327,13 @@ async function handleGrepDirect(api, table, sessionsTable, params) {
 }
 
 // dist/src/graph/vfs-handler.js
-import { existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { createHash as createHash3 } from "node:crypto";
-import { join as join13, dirname as dirname6 } from "node:path";
+import { join as join13, dirname as dirname7 } from "node:path";
 
 // dist/src/graph/last-build.js
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, join as join10 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync7, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join10 } from "node:path";
 function lastBuildPath(baseDir, worktreeId) {
   if (worktreeId !== void 0) {
     return join10(baseDir, "worktrees", worktreeId, ".last-build.json");
@@ -2332,18 +2341,18 @@ function lastBuildPath(baseDir, worktreeId) {
   return join10(baseDir, ".last-build.json");
 }
 function readLastBuild(baseDir, worktreeId) {
-  let path = lastBuildPath(baseDir, worktreeId);
-  if (!existsSync5(path)) {
+  let path2 = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync5(path2)) {
     if (worktreeId === void 0)
       return null;
     const legacy = lastBuildPath(baseDir, void 0);
     if (!existsSync5(legacy))
       return null;
-    path = legacy;
+    path2 = legacy;
   }
   let raw;
   try {
-    raw = readFileSync7(path, "utf8");
+    raw = readFileSync7(path2, "utf8");
   } catch {
     return null;
   }
@@ -2374,13 +2383,13 @@ function readLastBuild(baseDir, worktreeId) {
 
 // dist/src/graph/snapshot.js
 import { createHash } from "node:crypto";
-import { mkdirSync as mkdirSync7, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdirSync as mkdirSync8, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 
 // dist/src/graph/history.js
-import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname4, join as join11 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname5, join as join11 } from "node:path";
 
 // dist/src/graph/resolve/cross-file.js
 import { posix } from "node:path";
@@ -2952,18 +2961,18 @@ function workTreeIdFor(cwd) {
   return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
 }
 function handleGraphVfs(subpath, cwd) {
-  const path = subpath.replace(/^\/+/, "");
-  if (path === "" || path === "/") {
+  const path2 = subpath.replace(/^\/+/, "");
+  if (path2 === "" || path2 === "/") {
     return { kind: "ok", body: dirListing() };
   }
-  if (path === "index.md" || path === "index") {
+  if (path2 === "index.md" || path2 === "index") {
     return loadSnapshotOrError(cwd, (snap, baseDir) => ({
       kind: "ok",
       body: renderIndex(snap, baseDir, cwd)
     }));
   }
-  if (path.startsWith("find/")) {
-    const pattern = path.slice("find/".length);
+  if (path2.startsWith("find/")) {
+    const pattern = path2.slice("find/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "find/ requires a pattern: cat memory/graph/find/<keyword>" };
     }
@@ -2972,8 +2981,8 @@ function handleGraphVfs(subpath, cwd) {
       body: renderFind(snap, pattern, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("show/")) {
-    const key = path.slice("show/".length);
+  if (path2.startsWith("show/")) {
+    const key = path2.slice("show/".length);
     if (key === "") {
       return { kind: "not-found", message: "show/ requires a handle or pattern" };
     }
@@ -2982,8 +2991,8 @@ function handleGraphVfs(subpath, cwd) {
       body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("query/")) {
-    const pattern = path.slice("query/".length);
+  if (path2.startsWith("query/")) {
+    const pattern = path2.slice("query/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "query/ requires a pattern: cat memory/graph/query/<keyword>" };
     }
@@ -2992,28 +3001,28 @@ function handleGraphVfs(subpath, cwd) {
       body: renderQuery(snap, pattern, baseDir, workTreeIdFor(cwd))
     }));
   }
-  if (path.startsWith("impact/")) {
-    const pattern = path.slice("impact/".length);
+  if (path2.startsWith("impact/")) {
+    const pattern = path2.slice("impact/".length);
     if (pattern === "") {
       return { kind: "not-found", message: "impact/ requires a pattern: cat memory/graph/impact/<symbol>" };
     }
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderImpact(snap, pattern) }));
   }
-  if (path.startsWith("neighborhood/")) {
-    const file = path.slice("neighborhood/".length);
+  if (path2.startsWith("neighborhood/")) {
+    const file = path2.slice("neighborhood/".length);
     if (file === "") {
       return { kind: "not-found", message: "neighborhood/ requires a file path: cat memory/graph/neighborhood/<file>" };
     }
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderNeighborhood(snap, file) }));
   }
-  if (path === "layers" || path === "layers/" || path === "layers/index.md") {
+  if (path2 === "layers" || path2 === "layers/" || path2 === "layers/index.md") {
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderLayers(snap) }));
   }
-  if (path === "tour" || path === "tour/" || path === "tour/index.md") {
+  if (path2 === "tour" || path2 === "tour/" || path2 === "tour/index.md") {
     return loadSnapshotOrError(cwd, (snap) => ({ kind: "ok", body: renderTour(snap) }));
   }
-  if (path.startsWith("path/")) {
-    const rest = path.slice("path/".length);
+  if (path2.startsWith("path/")) {
+    const rest = path2.slice("path/".length);
     const slash = rest.indexOf("/");
     if (slash <= 0 || slash === rest.length - 1) {
       return { kind: "not-found", message: "path/ needs two patterns: cat memory/graph/path/<from>/<to> (each a symbol-name substring, no slash)" };
@@ -3024,7 +3033,7 @@ function handleGraphVfs(subpath, cwd) {
   }
   return {
     kind: "not-found",
-    message: `Unknown endpoint: graph/${path}
+    message: `Unknown endpoint: graph/${path2}
 Available: index.md, find/<pattern>, query/<pattern>, show/<handle-or-pattern>, impact/<pattern>, neighborhood/<file>, layers, tour, path/<from>/<to>`
   };
 }
@@ -3423,22 +3432,22 @@ function handlesPath(baseDir, worktreeId) {
   return join13(baseDir, "worktrees", worktreeId, ".find-handles.json");
 }
 function saveHandles(baseDir, worktreeId, ids, pattern) {
-  const path = handlesPath(baseDir, worktreeId);
+  const path2 = handlesPath(baseDir, worktreeId);
   const payload = { pattern, ts: Date.now(), ids };
   try {
-    mkdirSync8(dirname6(path), { recursive: true });
-    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    mkdirSync9(dirname7(path2), { recursive: true });
+    const tmp = `${path2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync7(tmp, JSON.stringify(payload));
-    renameSync5(tmp, path);
+    renameSync5(tmp, path2);
   } catch {
   }
 }
 function loadHandles(baseDir, worktreeId) {
-  const path = handlesPath(baseDir, worktreeId);
-  if (!existsSync7(path))
+  const path2 = handlesPath(baseDir, worktreeId);
+  if (!existsSync7(path2))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync9(path, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
     if (parsed === null || typeof parsed !== "object")
       return null;
     const o = parsed;
@@ -3529,8 +3538,8 @@ function tryGraphRead(rewrittenCommand, cwd) {
 }
 
 // dist/src/hooks/virtual-table-query.js
-function normalizeSessionPart(path, content) {
-  return normalizeContent(path, content);
+function normalizeSessionPart(path2, content) {
+  return normalizeContent(path2, content);
 }
 var INDEX_LIMIT_PER_SECTION = 50;
 function buildVirtualIndexContent(summaryRows, sessionRows = [], opts = {}) {
@@ -3597,7 +3606,7 @@ function buildUnionQuery(memoryQuery, sessionsQuery) {
   return `SELECT path, content, size_bytes, creation_date, source_order FROM ((${memoryQuery}) UNION ALL (${sessionsQuery})) AS combined ORDER BY path, source_order, creation_date`;
 }
 function buildInList(paths) {
-  return paths.map((path) => `'${sqlStr(path)}'`).join(", ");
+  return paths.map((path2) => `'${sqlStr(path2)}'`).join(", ");
 }
 function buildDirFilter(dirs) {
   const cleaned = [...new Set(dirs.map((dir) => dir.replace(/\/+$/, "") || "/"))];
@@ -3620,7 +3629,7 @@ async function queryUnionRows(api, memoryQuery, sessionsQuery) {
 }
 async function readVirtualPathContents(api, memoryTable, sessionsTable, virtualPaths) {
   const uniquePaths = [...new Set(virtualPaths)];
-  const result = new Map(uniquePaths.map((path) => [path, null]));
+  const result = new Map(uniquePaths.map((path2) => [path2, null]));
   if (uniquePaths.length === 0)
     return result;
   const inList = buildInList(uniquePaths);
@@ -3628,27 +3637,27 @@ async function readVirtualPathContents(api, memoryTable, sessionsTable, virtualP
   const memoryHits = /* @__PURE__ */ new Map();
   const sessionHits = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const path = row["path"];
+    const path2 = row["path"];
     const content = row["content"];
     const sourceOrder = Number(row["source_order"] ?? 0);
-    if (typeof path !== "string" || typeof content !== "string")
+    if (typeof path2 !== "string" || typeof content !== "string")
       continue;
     if (sourceOrder === 0) {
-      memoryHits.set(path, content);
+      memoryHits.set(path2, content);
     } else {
-      const current = sessionHits.get(path) ?? [];
-      current.push(normalizeSessionPart(path, content));
-      sessionHits.set(path, current);
+      const current = sessionHits.get(path2) ?? [];
+      current.push(normalizeSessionPart(path2, content));
+      sessionHits.set(path2, current);
     }
   }
-  for (const path of uniquePaths) {
-    if (memoryHits.has(path)) {
-      result.set(path, memoryHits.get(path) ?? null);
+  for (const path2 of uniquePaths) {
+    if (memoryHits.has(path2)) {
+      result.set(path2, memoryHits.get(path2) ?? null);
       continue;
     }
-    const sessionParts = sessionHits.get(path) ?? [];
+    const sessionParts = sessionHits.get(path2) ?? [];
     if (sessionParts.length > 0) {
-      result.set(path, sessionParts.join("\n"));
+      result.set(path2, sessionParts.join("\n"));
     }
   }
   if (result.get("/index.md") === null && uniquePaths.includes("/index.md")) {
@@ -3675,12 +3684,12 @@ async function listVirtualPathRowsForDirs(api, memoryTable, sessionsTable, dirs)
   for (const dir of uniqueDirs)
     byDir.set(dir, []);
   for (const row of deduped) {
-    const path = row["path"];
-    if (typeof path !== "string")
+    const path2 = row["path"];
+    if (typeof path2 !== "string")
       continue;
     for (const dir of uniqueDirs) {
       const prefix = dir === "/" ? "/" : `${dir}/`;
-      if (dir === "/" || path.startsWith(prefix)) {
+      if (dir === "/" || path2.startsWith(prefix)) {
         byDir.get(dir)?.push(row);
       }
     }
@@ -3703,10 +3712,10 @@ function dedupeRowsByPath(rows) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
   for (const row of rows) {
-    const path = typeof row["path"] === "string" ? row["path"] : "";
-    if (!path || seen.has(path))
+    const path2 = typeof row["path"] === "string" ? row["path"] : "";
+    if (!path2 || seen.has(path2))
       continue;
-    seen.add(path);
+    seen.add(path2);
     unique.push(row);
   }
   return unique;
@@ -3952,12 +3961,12 @@ function parseCompiledSegment(segment) {
       return null;
     if (headTokens[1] === "-n" && headTokens.length < 4 || /^-\d+$/.test(headTokens[1] ?? "") && headTokens.length < 3 || headTokens.length === 2 && /^-?\d+$/.test(headTokens[1] ?? ""))
       return null;
-    const path = headTokens[headTokens.length - 1];
-    if (path === "head" || path === "tail" || path === "-n")
+    const path2 = headTokens[headTokens.length - 1];
+    if (path2 === "head" || path2 === "tail" || path2 === "-n")
       return null;
     return {
       kind: "cat",
-      paths: expandBraceToken(path),
+      paths: expandBraceToken(path2),
       lineLimit: parsed.lineLimit,
       fromEnd: parsed.fromEnd,
       countLines: false,
@@ -4068,10 +4077,10 @@ function renderDirectoryListing(dir, rows, longFormat) {
   const entries = /* @__PURE__ */ new Map();
   const prefix = dir === "/" ? "/" : `${dir}/`;
   for (const row of rows) {
-    const path = row["path"];
-    if (!path.startsWith(prefix) && dir !== "/")
+    const path2 = row["path"];
+    if (!path2.startsWith(prefix) && dir !== "/")
       continue;
-    const rest = dir === "/" ? path.slice(1) : path.slice(prefix.length);
+    const rest = dir === "/" ? path2.slice(1) : path2.slice(prefix.length);
     const slash = rest.indexOf("/");
     const name = slash === -1 ? rest : rest.slice(0, slash);
     if (!name)
@@ -4115,8 +4124,8 @@ async function executeCompiledBashCommand(api, memoryTable, sessionsTable, cmd,
     }
     if (segment.kind === "cat") {
       const contents = [];
-      for (const path of segment.paths) {
-        const content = contentMap.get(path) ?? null;
+      for (const path2 of segment.paths) {
+        const content = contentMap.get(path2) ?? null;
         if (content === null) {
           if (segment.ignoreMissing)
             continue;
@@ -4153,11 +4162,11 @@ async function executeCompiledBashCommand(api, memoryTable, sessionsTable, cmd,
         continue;
       }
       const candidateContents = await readVirtualPathContentsFn(api, memoryTable, sessionsTable, candidatePaths);
-      const matched = refineGrepMatches(candidatePaths.flatMap((path) => {
-        const content = candidateContents.get(path);
+      const matched = refineGrepMatches(candidatePaths.flatMap((path2) => {
+        const content = candidateContents.get(path2);
         if (content === null || content === void 0)
           return [];
-        return [{ path, content: normalizeContent(path, content) }];
+        return [{ path: path2, content: normalizeContent(path2, content) }];
       }), segment.params);
       const limited = segment.lineLimit > 0 ? matched.slice(0, segment.lineLimit) : matched;
       outputs.push(limited.join("\n") || "(no matches)");
@@ -4179,7 +4188,7 @@ async function executeCompiledBashCommand(api, memoryTable, sessionsTable, cmd,
 }
 
 // dist/src/hooks/query-cache.js
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync10, rmSync, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join14 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 var log5 = (msg) => log("query-cache", msg);
@@ -4204,7 +4213,7 @@ function writeCachedIndexContent(sessionId, content, deps = {}) {
   const { logFn = log5 } = deps;
   try {
     const dir = getSessionQueryCacheDir(sessionId, deps);
-    mkdirSync9(dir, { recursive: true });
+    mkdirSync10(dir, { recursive: true });
     writeFileSync8(join14(dir, INDEX_CACHE_FILE), content, "utf-8");
   } catch (e) {
     logFn(`write failed for session=${sessionId}: ${e.message}`);
@@ -4372,7 +4381,227 @@ function rewritePaths(cmd) {
   return cmd.replace(new RegExp(escapeRe(MEMORY_PATH) + tail, "g"), "/").replace(new RegExp(escapeRe(TILDE_PATH) + tail, "g"), "/").replace(new RegExp('"' + escapeRe(HOME_VAR_PATH) + tail + '"', "g"), '"/"').replace(new RegExp(escapeRe(HOME_VAR_PATH) + tail, "g"), "/");
 }
 
+// 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 fileURLToPath3 } from "node:url";
+
+// dist/src/skillify/state-dir.js
+import { homedir as homedir11 } from "node:os";
+import { join as join16 } from "node:path";
+function getStateDir() {
+  const override = process.env.HIVEMIND_STATE_DIR?.trim();
+  return override && override.length > 0 ? override : join16(homedir11(), ".deeplake", "state", "skillify");
+}
+
+// dist/src/skillify/skill-invocations.js
+function pathToSkillRef(s) {
+  if (typeof s !== "string")
+    return null;
+  const m = s.match(/\/skills\/(?:[^/\s"'`]+\/)*([^/\s"'`]+)\/SKILL\.md/);
+  return m ? m[1] : null;
+}
+function splitOrgSkill(skill) {
+  if (skill.includes(":"))
+    return null;
+  if (skill.includes("/") || skill.includes("\\") || skill.includes(".."))
+    return null;
+  const i = skill.lastIndexOf("--");
+  if (i <= 0 || i + 2 >= skill.length)
+    return null;
+  return { name: skill.slice(0, i), author: skill.slice(i + 2) };
+}
+
+// dist/src/skillify/manifest.js
+import { existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync11, readFileSync as readFileSync11, renameSync as renameSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, join as join18 } from "node:path";
+
+// dist/src/skillify/legacy-migration.js
+import { existsSync as existsSync8, renameSync as renameSync6 } from "node:fs";
+import { dirname as dirname8, join as join17 } from "node:path";
+var dlog = (msg) => log("skillify-migrate", msg);
+var attempted = false;
+function migrateLegacyStateDir() {
+  if (process.env.HIVEMIND_STATE_DIR?.trim())
+    return;
+  if (attempted)
+    return;
+  attempted = true;
+  const current = getStateDir();
+  const legacy = join17(dirname8(current), "skilify");
+  if (!existsSync8(legacy))
+    return;
+  if (existsSync8(current))
+    return;
+  try {
+    renameSync6(legacy, current);
+    dlog(`migrated ${legacy} -> ${current}`);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EXDEV" || code === "EPERM" || code === "ENOENT" || code === "EEXIST" || code === "ENOTEMPTY") {
+      dlog(`migration skipped (${code}); legacy dir left as-is or another process handled it`);
+      return;
+    }
+    throw err;
+  }
+}
+
+// dist/src/skillify/manifest.js
+function emptyManifest() {
+  return { version: 1, entries: [] };
+}
+function manifestPath() {
+  return join18(getStateDir(), "pulled.json");
+}
+function loadManifest(path2 = manifestPath()) {
+  migrateLegacyStateDir();
+  if (!existsSync9(path2))
+    return emptyManifest();
+  let raw;
+  try {
+    raw = readFileSync11(path2, "utf-8");
+  } catch {
+    return emptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return emptyManifest();
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+      return emptyManifest();
+    const entries = [];
+    for (const e of parsed.entries) {
+      if (!e || typeof e !== "object")
+        continue;
+      if (typeof e.dirName !== "string" || !e.dirName)
+        continue;
+      if (e.dirName.includes("/") || e.dirName.includes("\\") || e.dirName.includes(".."))
+        continue;
+      if (typeof e.name !== "string" || !e.name)
+        continue;
+      if (typeof e.author !== "string")
+        continue;
+      if (typeof e.installRoot !== "string" || !e.installRoot)
+        continue;
+      if (e.install !== "global" && e.install !== "project")
+        continue;
+      const symlinks = Array.isArray(e.symlinks) ? e.symlinks.filter((p) => typeof p === "string" && p.length > 0 && (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)) && // absolute (POSIX or Windows)
+      !p.includes("..")) : [];
+      entries.push({
+        dirName: e.dirName,
+        name: e.name,
+        author: e.author,
+        projectKey: typeof e.projectKey === "string" ? e.projectKey : "",
+        remoteVersion: typeof e.remoteVersion === "number" ? e.remoteVersion : 1,
+        install: e.install,
+        installRoot: e.installRoot,
+        pulledAt: typeof e.pulledAt === "string" ? e.pulledAt : (/* @__PURE__ */ new Date()).toISOString(),
+        symlinks
+      });
+    }
+    return { version: 1, entries };
+  } catch {
+    return emptyManifest();
+  }
+}
+
+// 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 DEFAULT_JUDGE_WINDOW = 3;
+function judgeWindow(env = process.env) {
+  const n = Number(env[SKILLOPT_ENV.JUDGE_WINDOW]);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_JUDGE_WINDOW;
+}
+function defaultIsOrgSkill(skillRef) {
+  try {
+    return loadManifest().entries.some((e) => e.dirName === skillRef);
+  } catch {
+    return false;
+  }
+}
+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 markSkillPending(sessionId, skillRef, toolUseId, deps = {}) {
+  if (!sessionId || !skillRef)
+    return false;
+  if (!splitOrgSkill(skillRef))
+    return false;
+  if (!(deps.isOrgSkill ?? defaultIsOrgSkill)(skillRef))
+    return false;
+  (deps.store ?? fileStore).save(sessionId, { skill: skillRef, budget: judgeWindow(deps.env ?? process.env), toolUseId });
+  return true;
+}
+
+// dist/src/hooks/shared/skillopt-hook.js
+function skillRefFromSkillFileRead(toolName, toolInput) {
+  if (/^read$/i.test(toolName))
+    return pathToSkillRef(toolInput?.path);
+  return pathToSkillRef(toolInput?.command);
+}
+function armSkillOptOnSkillUse(sessionId, toolName, toolInput, toolUseId) {
+  try {
+    if (process.env[SKILLOPT_ENV.DISABLED] === "1")
+      return;
+    let ref = null;
+    if (toolName === "Skill") {
+      const s = toolInput?.skill;
+      ref = typeof s === "string" ? s : null;
+    } else {
+      ref = skillRefFromSkillFileRead(toolName, toolInput);
+    }
+    if (ref)
+      markSkillPending(sessionId, ref, toolUseId);
+  } catch {
+  }
+}
+
 // dist/src/hooks/codex/pre-tool-use.js
+var __bundleDir = dirname10(fileURLToPath4(import.meta.url));
 var log6 = (msg) => log("codex-pre", msg);
 function buildUnsupportedGuidance() {
   return "This command is not supported for ~/.deeplake/memory/ operations. Only bash builtins are available: cat, ls, grep, echo, jq, head, tail, wc, sort, find, etc. Do NOT use python, python3, node, curl, or other interpreters. Rewrite your command using only bash tools and retry.";
@@ -4380,11 +4609,11 @@ function buildUnsupportedGuidance() {
 function buildIndexContent(rows) {
   const lines = ["# Memory Index", "", `${rows.length} sessions:`, ""];
   for (const row of rows) {
-    const path = row["path"];
+    const path2 = row["path"];
     const project = row["project"] || "";
     const description = (row["description"] || "").slice(0, 120);
     const date = (row["creation_date"] || "").slice(0, 10);
-    lines.push(`- [${path}](${path}) ${date} ${project ? `[${project}]` : ""} ${description}`);
+    lines.push(`- [${path2}](${path2}) ${date} ${project ? `[${project}]` : ""} ${description}`);
   }
   return lines.join("\n");
 }
@@ -4414,16 +4643,16 @@ async function processCodexPreToolUse(input, deps = {}) {
     const api = createApi(table, config);
     const readVirtualPathContentsWithCache = async (cachePaths) => {
       const uniquePaths = [...new Set(cachePaths)];
-      const result = new Map(uniquePaths.map((path) => [path, null]));
+      const result = new Map(uniquePaths.map((path2) => [path2, null]));
       const cachedIndex = uniquePaths.includes("/index.md") ? readCachedIndexContentFn(input.session_id) : null;
-      const remainingPaths = cachedIndex === null ? uniquePaths : uniquePaths.filter((path) => path !== "/index.md");
+      const remainingPaths = cachedIndex === null ? uniquePaths : uniquePaths.filter((path2) => path2 !== "/index.md");
       if (cachedIndex !== null) {
         result.set("/index.md", cachedIndex);
       }
       if (remainingPaths.length > 0) {
         const fetched = await readVirtualPathContentsFn(api, table, sessionsTable, remainingPaths);
-        for (const [path, content] of fetched)
-          result.set(path, content);
+        for (const [path2, content] of fetched)
+          result.set(path2, content);
       }
       const fetchedIndex = result.get("/index.md");
       if (typeof fetchedIndex === "string") {
@@ -4519,10 +4748,10 @@ async function processCodexPreToolUse(input, deps = {}) {
         const entries = /* @__PURE__ */ new Map();
         const prefix = dir === "/" ? "/" : `${dir}/`;
         for (const row of rows) {
-          const path = row["path"];
-          if (!path.startsWith(prefix) && dir !== "/")
+          const path2 = row["path"];
+          if (!path2.startsWith(prefix) && dir !== "/")
             continue;
-          const rest = dir === "/" ? path.slice(1) : path.slice(prefix.length);
+          const rest = dir === "/" ? path2.slice(1) : path2.slice(prefix.length);
           const slash = rest.indexOf("/");
           const name = slash === -1 ? rest : rest.slice(0, slash);
           if (!name)
@@ -4582,15 +4811,29 @@ async function processCodexPreToolUse(input, deps = {}) {
       logFn(`direct query failed: ${e.message}`);
     }
   }
-  logFn(`unroutable memory command, blocking with guidance: ${rewritten}`);
-  return {
-    action: "block",
-    output: buildUnsupportedGuidance(),
-    rewrittenCommand: rewritten
-  };
+  const isWriteRedirect = /^\s*(echo|printf|tee)\b/.test(rewritten) && /\s>>?\s/.test(rewritten);
+  const shellBundle = join19(__bundleDir, "shell", "deeplake-shell.js");
+  logFn(`unroutable memory command, falling back to VFS shell: ${rewritten}`);
+  try {
+    const proc = spawnSync("node", [shellBundle, "-c", rewritten], {
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (proc.status === 0 || proc.stdout && proc.stdout.trim()) {
+      const output = (proc.stdout?.trim() ?? "") || "(done)";
+      return { action: isWriteRedirect ? "guide" : "block", output, rewrittenCommand: rewritten };
+    }
+    return { action: "block", output: buildUnsupportedGuidance(), rewrittenCommand: rewritten };
+  } catch {
+    return { action: "block", output: buildUnsupportedGuidance(), rewrittenCommand: rewritten };
+  }
 }
 async function main() {
   const input = await readStdin();
+  try {
+    armSkillOptOnSkillUse(input.session_id, input.tool_name, input.tool_input, input.tool_use_id);
+  } catch {
+  }
   const decision = await processCodexPreToolUse(input);
   if (decision.action === "pass")
     return;