@deeplake/hivemind 0.7.54 → 0.7.61

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.54"
+    "version": "0.7.61"
   },
   "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.54",
+      "version": "0.7.61",
       "source": {
         "source": "git-subdir",
         "url": "https://github.com/activeloopai/hivemind.git",
         "path": "claude-code",
-        "sha": "0c6a32fe771809bd04f9ae7ff9790d216494afd5"
+        "sha": "edf4a6520595067cd8c0f6064034014e3fc2790e"
       },
       "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.54",
+  "version": "0.7.61",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/README.md

@@ -279,6 +279,8 @@ This plugin captures session activity and stores it in your Deeplake workspace:
 | `HIVEMIND_SESSIONS_TABLE` | `sessions`                | SQL table for per-event session capture    |
 | `HIVEMIND_MEMORY_PATH`    | `~/.deeplake/memory`      | Path that triggers interception            |
 | `HIVEMIND_CAPTURE`        | `true`                    | Set to `false` to disable capture          |
+| `HIVEMIND_CAPTURE_ONLY_CLI` | —                       | Set to `true` to capture only interactive CLI sessions. Sessions spawned by the Claude Agent SDK (Python/TypeScript) are skipped — their `CLAUDE_CODE_ENTRYPOINT` is `sdk-py` / `sdk-ts`, so they fail the substring check for `cli`. |
+| `HIVEMIND_SKILLIFY_EVERY_N_TURNS` | `20`              | Assistant turns between auto skill-mining attempts. Lower = more frequent mining (cheaper sessions, noisier output); higher = fewer attempts on longer histories. |
 | `HIVEMIND_EMBEDDINGS`     | `true`                    | Set to `false` to force lexical-only mode  |
 | `HIVEMIND_DEBUG`          | —                         | Set to `1` for verbose hook debug logs     |
 

package/bundle/cli.js

@@ -5094,6 +5094,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {
@@ -9044,21 +9061,25 @@ async function runPull(opts) {
     skillName: opts.skillName
   });
   let rows = [];
-  try {
-    rows = await opts.query(sql);
-  } catch (e) {
-    if (isMissingTableError2(e?.message)) {
-      rows = [];
-    } else if (isMissingContributorsColumnError(e?.message)) {
-      const legacySql = buildPullSql({
-        tableName: opts.tableName,
-        users: opts.users,
-        skillName: opts.skillName,
-        includeContributors: false
-      });
-      rows = await opts.query(legacySql);
-    } else {
-      throw e;
+  if (opts.tableExists && !opts.tableExists(opts.tableName)) {
+    rows = [];
+  } else {
+    try {
+      rows = await opts.query(sql);
+    } catch (e) {
+      if (isMissingTableError2(e?.message)) {
+        rows = [];
+      } else if (isMissingContributorsColumnError(e?.message)) {
+        const legacySql = buildPullSql({
+          tableName: opts.tableName,
+          users: opts.users,
+          skillName: opts.skillName,
+          includeContributors: false
+        });
+        rows = await opts.query(legacySql);
+      } else {
+        throw e;
+      }
     }
   }
   const latest = selectLatestPerName(rows);
@@ -11221,24 +11242,33 @@ async function renderContextBlock(query, input, opts = {}) {
   const log8 = opts.log ?? (() => {
   });
   try {
+    const tableExists = opts.tableExists;
     let rules = [];
-    try {
-      rules = await listRules(query, input.rulesTable, {
-        status: "active",
-        limit: Math.max(maxRules * 4, maxRules + 1)
-      });
-    } catch (rulesErr) {
-      const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
-      log8(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+    if (tableExists && !tableExists(input.rulesTable)) {
+      log8(`render-context-block: rules table "${input.rulesTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        rules = await listRules(query, input.rulesTable, {
+          status: "active",
+          limit: Math.max(maxRules * 4, maxRules + 1)
+        });
+      } catch (rulesErr) {
+        const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
+        log8(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+      }
     }
     let goals = [];
-    try {
-      goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
-        limit: Math.max(maxGoals * 4, maxGoals + 1)
-      });
-    } catch (goalsErr) {
-      const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
-      log8(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+    if (tableExists && !tableExists(input.goalsTable)) {
+      log8(`render-context-block: goals table "${input.goalsTable}" not present \u2014 skipping read`);
+    } else {
+      try {
+        goals = await listOpenGoals(query, input.goalsTable, input.currentUser, {
+          limit: Math.max(maxGoals * 4, maxGoals + 1)
+        });
+      } catch (goalsErr) {
+        const gmsg = goalsErr instanceof Error ? goalsErr.message : String(goalsErr);
+        log8(`render-context-block: goals unavailable (continuing): ${gmsg}`);
+      }
     }
     const rulesShown = rules.slice(0, maxRules);
     const rulesHidden = Math.max(0, rules.length - maxRules);
@@ -11353,11 +11383,13 @@ async function runContextCommand(args) {
     throw new Error("unreachable");
   }
   const api = new DeeplakeApi(cfg.token, cfg.apiUrl, cfg.orgId, cfg.workspaceId, cfg.tableName);
+  const known = await api.knownTablesOrNull();
+  const tableExists = known ? (name) => known.includes(name) : void 0;
   const block = await renderContextBlock((sql) => api.query(sql), {
     rulesTable: cfg.rulesTableName,
     goalsTable: cfg.goalsTableName,
     currentUser: cfg.userName
-  });
+  }, { tableExists });
   if (!block) {
     console.error("(no active rules or open goals)");
     return;

package/codex/bundle/capture.js

@@ -756,6 +756,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

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

@@ -1019,6 +1019,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/codex/bundle/graph-pull-worker.js

@@ -746,6 +746,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/codex/bundle/pre-tool-use.js

@@ -762,6 +762,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/codex/bundle/session-start-setup.js

@@ -757,6 +757,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/codex/bundle/session-start.js

@@ -996,6 +996,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {
@@ -1675,21 +1692,25 @@ async function runPull(opts) {
     skillName: opts.skillName
   });
   let rows = [];
-  try {
-    rows = await opts.query(sql);
-  } catch (e) {
-    if (isMissingTableError(e?.message)) {
-      rows = [];
-    } else if (isMissingContributorsColumnError(e?.message)) {
-      const legacySql = buildPullSql({
-        tableName: opts.tableName,
-        users: opts.users,
-        skillName: opts.skillName,
-        includeContributors: false
-      });
-      rows = await opts.query(legacySql);
-    } else {
-      throw e;
+  if (opts.tableExists && !opts.tableExists(opts.tableName)) {
+    rows = [];
+  } else {
+    try {
+      rows = await opts.query(sql);
+    } catch (e) {
+      if (isMissingTableError(e?.message)) {
+        rows = [];
+      } else if (isMissingContributorsColumnError(e?.message)) {
+        const legacySql = buildPullSql({
+          tableName: opts.tableName,
+          users: opts.users,
+          skillName: opts.skillName,
+          includeContributors: false
+        });
+        rows = await opts.query(legacySql);
+      } else {
+        throw e;
+      }
     }
   }
   const latest = selectLatestPerName(rows);
@@ -1832,24 +1853,38 @@ async function autoPullSkills(deps = {}) {
     return { pulled: 0, skipped: true, reason: "not-logged-in" };
   }
   let query;
+  let discoverTableExists = async () => void 0;
   if (deps.queryFn) {
     query = deps.queryFn;
   } else {
     const api = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.skillsTableName);
     query = (sql) => api.query(sql);
+    discoverTableExists = async () => {
+      const known = await api.knownTablesOrNull();
+      return known ? (name) => known.includes(name) : void 0;
+    };
   }
   const install = deps.install ?? "global";
   const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   try {
-    const summary = await withTimeout(runPull({
-      query,
-      tableName: config.skillsTableName,
-      install,
-      cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
-      users: [],
-      dryRun: false,
-      force: false
-    }), timeoutMs);
+    const summary = await withTimeout(
+      // Table discovery + pull share one budget: if `GET /tables` hangs the
+      // whole thing times out and we degrade, instead of blocking startup.
+      (async () => {
+        const tableExists = await discoverTableExists();
+        return runPull({
+          query,
+          tableName: config.skillsTableName,
+          install,
+          cwd: install === "project" ? deps.cwd ?? process.cwd() : void 0,
+          users: [],
+          dryRun: false,
+          force: false,
+          tableExists
+        });
+      })(),
+      timeoutMs
+    );
     log4(`pulled scanned=${summary.scanned} wrote=${summary.wrote} skipped=${summary.skipped}`);
     return { pulled: summary.wrote, skipped: false };
   } catch (e) {

package/codex/bundle/shell/deeplake-shell.js

@@ -67450,6 +67450,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/codex/bundle/stop.js

@@ -761,6 +761,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/cursor/bundle/capture.js

@@ -756,6 +756,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

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

@@ -1019,6 +1019,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/cursor/bundle/graph-pull-worker.js

@@ -746,6 +746,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {

package/cursor/bundle/pre-tool-use.js

@@ -755,6 +755,23 @@ var DeeplakeApi = class {
       this._tablesCache = [...tables];
     return tables;
   }
+  /**
+   * Like listTables() but returns null when the list could NOT be trusted
+   * (the fetch failed / was non-cacheable). Callers gating a read on table
+   * existence use this to tell a genuinely-empty workspace ([]) apart from a
+   * failed lookup (null): on [] they can safely skip the read (no table → no
+   * 42P01), on null they must fall back to SELECT-then-catch so a transient
+   * lookup blip doesn't drop a read of a table that really exists.
+   */
+  async knownTablesOrNull() {
+    if (this._tablesCache)
+      return [...this._tablesCache];
+    const { tables, cacheable } = await this._fetchTables();
+    if (!cacheable)
+      return null;
+    this._tablesCache = [...tables];
+    return [...tables];
+  }
   async _fetchTables() {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
       try {