@deeplake/hivemind 0.7.74 → 0.7.76

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.74"
+    "version": "0.7.76"
   },
   "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.74",
+      "version": "0.7.76",
       "source": {
         "source": "git-subdir",
         "url": "https://github.com/activeloopai/hivemind.git",
         "path": "claude-code",
-        "sha": "c36c84a01eeb6ebac5211c6ce485283977e484d1"
+        "sha": "d3dd170f102bf2543acc874d236d766542295e8e"
       },
       "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.74",
+  "version": "0.7.76",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/codex/bundle/capture.js

@@ -1846,7 +1846,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/codex/bundle/session-start.js

@@ -112,6 +112,19 @@ function decodeJwtPayload(token) {
     return null;
   }
 }
+async function apiGet(path, token, apiUrl, orgId) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
+  };
+  if (orgId)
+    headers["X-Activeloop-Org-Id"] = orgId;
+  const resp = await fetch(`${apiUrl}${path}`, { headers });
+  if (!resp.ok)
+    throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
+  return resp.json();
+}
 async function apiPost(path, body, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
@@ -125,6 +138,10 @@ async function apiPost(path, body, token, apiUrl, orgId) {
     throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
   return resp.json();
 }
+async function listOrgs(token, apiUrl = DEFAULT_API_URL) {
+  const data = await apiGet("/organizations", token, apiUrl);
+  return Array.isArray(data) ? data : [];
+}
 async function healDriftedOrgToken(creds, log6 = () => {
 }) {
   if (!creds.token || !creds.orgId)
@@ -143,6 +160,33 @@ async function healDriftedOrgToken(creds, log6 = () => {
       organization_id: creds.orgId
     }, creds.token, apiUrl);
     const healed = { ...creds, token: tokenData.token.token };
+    try {
+      const orgs = await listOrgs(healed.token, apiUrl);
+      const matchedOrg = orgs.find((o) => o.id === creds.orgId);
+      if (matchedOrg && matchedOrg.name !== creds.orgName) {
+        log6(`orgName realigned: ${creds.orgName ?? "(unset)"} -> ${matchedOrg.name}`);
+        healed.orgName = matchedOrg.name;
+      }
+    } catch (e) {
+      log6(`orgName realign skipped: ${e.message}`);
+    }
+    const currentWs = creds.workspaceId ?? "default";
+    if (currentWs !== "default") {
+      try {
+        const wsList = await listWorkspaces(healed.token, apiUrl, creds.orgId);
+        const lcWs = currentWs.toLowerCase();
+        const wsMatch = wsList.find((w) => w.id === currentWs || w.name && w.name.toLowerCase() === lcWs);
+        if (!wsMatch) {
+          log6(`workspace '${currentWs}' not in org ${creds.orgId} \u2014 reset to default`);
+          healed.workspaceId = "default";
+        } else if (wsMatch.id !== currentWs) {
+          log6(`workspace '${currentWs}' resolved to id '${wsMatch.id}'`);
+          healed.workspaceId = wsMatch.id;
+        }
+      } catch (e) {
+        log6(`workspace realign skipped: ${e.message}`);
+      }
+    }
     saveCredentials(healed);
     log6(`token re-minted for org=${creds.orgId}`);
     return healed;
@@ -151,6 +195,11 @@ async function healDriftedOrgToken(creds, log6 = () => {
     return creds;
   }
 }
+async function listWorkspaces(token, apiUrl = DEFAULT_API_URL, orgId) {
+  const raw = await apiGet("/workspaces", token, apiUrl, orgId);
+  const data = raw.data ?? raw;
+  return Array.isArray(data) ? data : [];
+}
 
 // dist/src/utils/stdin.js
 function readStdin() {

package/codex/bundle/stop.js

@@ -1126,7 +1126,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/cursor/bundle/capture.js

@@ -1846,7 +1846,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/cursor/bundle/session-end.js

@@ -269,7 +269,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/cursor/bundle/session-start.js

@@ -111,6 +111,19 @@ function decodeJwtPayload(token) {
     return null;
   }
 }
+async function apiGet(path, token, apiUrl, orgId) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
+  };
+  if (orgId)
+    headers["X-Activeloop-Org-Id"] = orgId;
+  const resp = await fetch(`${apiUrl}${path}`, { headers });
+  if (!resp.ok)
+    throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
+  return resp.json();
+}
 async function apiPost(path, body, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
@@ -124,6 +137,10 @@ async function apiPost(path, body, token, apiUrl, orgId) {
     throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
   return resp.json();
 }
+async function listOrgs(token, apiUrl = DEFAULT_API_URL) {
+  const data = await apiGet("/organizations", token, apiUrl);
+  return Array.isArray(data) ? data : [];
+}
 async function healDriftedOrgToken(creds, log7 = () => {
 }) {
   if (!creds.token || !creds.orgId)
@@ -142,6 +159,33 @@ async function healDriftedOrgToken(creds, log7 = () => {
       organization_id: creds.orgId
     }, creds.token, apiUrl);
     const healed = { ...creds, token: tokenData.token.token };
+    try {
+      const orgs = await listOrgs(healed.token, apiUrl);
+      const matchedOrg = orgs.find((o) => o.id === creds.orgId);
+      if (matchedOrg && matchedOrg.name !== creds.orgName) {
+        log7(`orgName realigned: ${creds.orgName ?? "(unset)"} -> ${matchedOrg.name}`);
+        healed.orgName = matchedOrg.name;
+      }
+    } catch (e) {
+      log7(`orgName realign skipped: ${e.message}`);
+    }
+    const currentWs = creds.workspaceId ?? "default";
+    if (currentWs !== "default") {
+      try {
+        const wsList = await listWorkspaces(healed.token, apiUrl, creds.orgId);
+        const lcWs = currentWs.toLowerCase();
+        const wsMatch = wsList.find((w) => w.id === currentWs || w.name && w.name.toLowerCase() === lcWs);
+        if (!wsMatch) {
+          log7(`workspace '${currentWs}' not in org ${creds.orgId} \u2014 reset to default`);
+          healed.workspaceId = "default";
+        } else if (wsMatch.id !== currentWs) {
+          log7(`workspace '${currentWs}' resolved to id '${wsMatch.id}'`);
+          healed.workspaceId = wsMatch.id;
+        }
+      } catch (e) {
+        log7(`workspace realign skipped: ${e.message}`);
+      }
+    }
     saveCredentials(healed);
     log7(`token re-minted for org=${creds.orgId}`);
     return healed;
@@ -150,6 +194,11 @@ async function healDriftedOrgToken(creds, log7 = () => {
     return creds;
   }
 }
+async function listWorkspaces(token, apiUrl = DEFAULT_API_URL, orgId) {
+  const raw = await apiGet("/workspaces", token, apiUrl, orgId);
+  const data = raw.data ?? raw;
+  return Array.isArray(data) ? data : [];
+}
 
 // dist/src/config.js
 import { readFileSync as readFileSync3, existsSync } from "node:fs";

package/hermes/bundle/capture.js

@@ -1845,7 +1845,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/hermes/bundle/session-end.js

@@ -267,7 +267,7 @@ Format: **entity** (type) \u2014 what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate \u2014 not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES \u2014 work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome \u2014 or a competent engineer would simply re-derive the work from the code, tests, comments, or git state \u2014 write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding \u2014 reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 \u2014 is the work this session set out to do actually finished? If it ended mid-task \u2014 a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging \u2014 then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step \u2014 never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 \u2014 if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI \u2014 treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.

package/hermes/bundle/session-start.js

@@ -110,6 +110,19 @@ function decodeJwtPayload(token) {
     return null;
   }
 }
+async function apiGet(path, token, apiUrl, orgId) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    ...deeplakeClientHeader()
+  };
+  if (orgId)
+    headers["X-Activeloop-Org-Id"] = orgId;
+  const resp = await fetch(`${apiUrl}${path}`, { headers });
+  if (!resp.ok)
+    throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
+  return resp.json();
+}
 async function apiPost(path, body, token, apiUrl, orgId) {
   const headers = {
     Authorization: `Bearer ${token}`,
@@ -123,6 +136,10 @@ async function apiPost(path, body, token, apiUrl, orgId) {
     throw new Error(`API ${resp.status}: ${await resp.text().catch(() => "")}`);
   return resp.json();
 }
+async function listOrgs(token, apiUrl = DEFAULT_API_URL) {
+  const data = await apiGet("/organizations", token, apiUrl);
+  return Array.isArray(data) ? data : [];
+}
 async function healDriftedOrgToken(creds, log7 = () => {
 }) {
   if (!creds.token || !creds.orgId)
@@ -141,6 +158,33 @@ async function healDriftedOrgToken(creds, log7 = () => {
       organization_id: creds.orgId
     }, creds.token, apiUrl);
     const healed = { ...creds, token: tokenData.token.token };
+    try {
+      const orgs = await listOrgs(healed.token, apiUrl);
+      const matchedOrg = orgs.find((o) => o.id === creds.orgId);
+      if (matchedOrg && matchedOrg.name !== creds.orgName) {
+        log7(`orgName realigned: ${creds.orgName ?? "(unset)"} -> ${matchedOrg.name}`);
+        healed.orgName = matchedOrg.name;
+      }
+    } catch (e) {
+      log7(`orgName realign skipped: ${e.message}`);
+    }
+    const currentWs = creds.workspaceId ?? "default";
+    if (currentWs !== "default") {
+      try {
+        const wsList = await listWorkspaces(healed.token, apiUrl, creds.orgId);
+        const lcWs = currentWs.toLowerCase();
+        const wsMatch = wsList.find((w) => w.id === currentWs || w.name && w.name.toLowerCase() === lcWs);
+        if (!wsMatch) {
+          log7(`workspace '${currentWs}' not in org ${creds.orgId} \u2014 reset to default`);
+          healed.workspaceId = "default";
+        } else if (wsMatch.id !== currentWs) {
+          log7(`workspace '${currentWs}' resolved to id '${wsMatch.id}'`);
+          healed.workspaceId = wsMatch.id;
+        }
+      } catch (e) {
+        log7(`workspace realign skipped: ${e.message}`);
+      }
+    }
     saveCredentials(healed);
     log7(`token re-minted for org=${creds.orgId}`);
     return healed;
@@ -149,6 +193,11 @@ async function healDriftedOrgToken(creds, log7 = () => {
     return creds;
   }
 }
+async function listWorkspaces(token, apiUrl = DEFAULT_API_URL, orgId) {
+  const raw = await apiGet("/workspaces", token, apiUrl, orgId);
+  const data = raw.data ?? raw;
+  return Array.isArray(data) ? data : [];
+}
 
 // dist/src/config.js
 import { readFileSync as readFileSync3, existsSync } from "node:fs";

package/openclaw/dist/index.js

@@ -148,6 +148,33 @@ async function healDriftedOrgToken(creds, log4 = () => {
       organization_id: creds.orgId
     }, creds.token, apiUrl);
     const healed = { ...creds, token: tokenData.token.token };
+    try {
+      const orgs = await listOrgs(healed.token, apiUrl);
+      const matchedOrg = orgs.find((o) => o.id === creds.orgId);
+      if (matchedOrg && matchedOrg.name !== creds.orgName) {
+        log4(`orgName realigned: ${creds.orgName ?? "(unset)"} -> ${matchedOrg.name}`);
+        healed.orgName = matchedOrg.name;
+      }
+    } catch (e) {
+      log4(`orgName realign skipped: ${e.message}`);
+    }
+    const currentWs = creds.workspaceId ?? "default";
+    if (currentWs !== "default") {
+      try {
+        const wsList = await listWorkspaces(healed.token, apiUrl, creds.orgId);
+        const lcWs = currentWs.toLowerCase();
+        const wsMatch = wsList.find((w) => w.id === currentWs || w.name && w.name.toLowerCase() === lcWs);
+        if (!wsMatch) {
+          log4(`workspace '${currentWs}' not in org ${creds.orgId} \u2014 reset to default`);
+          healed.workspaceId = "default";
+        } else if (wsMatch.id !== currentWs) {
+          log4(`workspace '${currentWs}' resolved to id '${wsMatch.id}'`);
+          healed.workspaceId = wsMatch.id;
+        }
+      } catch (e) {
+        log4(`workspace realign skipped: ${e.message}`);
+      }
+    }
     saveCredentials(healed);
     log4(`token re-minted for org=${creds.orgId}`);
     return healed;
@@ -1801,7 +1828,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.74".length > 0 ? "0.7.74" : null;
+  return "0.7.76".length > 0 ? "0.7.76" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);

package/openclaw/openclaw.plugin.json

@@ -54,5 +54,5 @@
       }
     }
   },
-  "version": "0.7.74"
+  "version": "0.7.76"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.74",
+  "version": "0.7.76",
   "type": "module",
   "description": "Hivemind — cloud-backed persistent shared memory for AI agents, powered by DeepLake",
   "license": "Apache-2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.7.74",
+  "version": "0.7.76",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {

package/pi/extension-source/hivemind.ts

@@ -602,7 +602,7 @@ Format: **entity** (type) — what was done with it, its current state>
 <Anything unresolved, blocked, or explicitly deferred>
 
 ## Next Steps
-<Default to writing exactly: none. When in any doubt at all, write none. Do NOT assume any base rate — not that next steps are usually warranted, nor that they usually are not; the right frequency depends entirely on the work and varies by session and use case. Judge THIS session purely on the gate below, never on how often the section "should" be filled. The bar is deliberately EXTREME: name a next step ONLY when failing to surface it would cause the project to MISS SOMETHING IMPORTANT WITH SUBSTANTIAL CONSEQUENCES — work silently lost, a known bug or regression shipping to users, data or state left corrupted/unsafe, a security or data-integrity hole left open, or a critical blocker/decision that a returning engineer would NOT rediscover on their own and would be materially harmed by not knowing. Before you write anything other than none, apply this gate: state to yourself the specific, concrete, substantial bad outcome that follows if the user NEVER sees this line. If you cannot name a concrete bad outcome — or a competent engineer would simply re-derive the work from the code, tests, comments, or git state — write none. A next step is NOT: a nice-to-have, a polish or cleanup item, a "could also" / "consider", the obvious natural continuation of the task, an open-ended exploration, a trivial or mechanical follow-up, or any administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI — treat ALL such wrap-up as ALREADY DONE). It is a flag raised solely because real, describable harm follows from silence. When (rarely) the gate is genuinely passed, write a single concrete imperative line that names the substantive work AND makes the stakes obvious (e.g. "Fix the uint32 class_label scan binding — reads silently return wrong values until corrected"). Administrative actions qualify ONLY when the session's core purpose itself was that release/ops task.>
+<Decide in two steps. STEP 1 — is the work this session set out to do actually finished? If it ended mid-task — a feature only half-implemented, a build or test still failing, a fix written but not yet verified, a plan agreed but not executed, a blocker hit and unresolved, or an explicit "still need to.../next I'll..." left hanging — then it is NOT finished and you MUST write a single concrete imperative line naming the unfinished work (e.g. "Finish wiring the uint32 class_label scan binding and run its test"). The session's LAST messages are the strongest signal: if they describe or show work still in progress or something left to do, that IS the next step — never suppress a genuinely unfinished task, and do not demand "substantial consequences" for it. STEP 2 — if the core work IS finished, default to exactly: none and do not invent a follow-up to fill the section. Write none when the work reached a natural stopping point, only trivial/obvious/optional polish or cleanup remains, the "next step" would just be open-ended exploration, or the only thing left is administrative wrap-up (committing, pushing, opening/merging a PR, deploying, monitoring CI — treat ALL such wrap-up as ALREADY DONE). The sole exception that still warrants a next step on otherwise-finished work is a separate, important, non-obvious item a returning engineer would NOT realize on their own and would be materially harmed by missing.>
 
 IMPORTANT: Be exhaustive. Extract EVERY entity, decision, and fact.
 PRIVACY: Never include absolute filesystem paths in the summary.