@deeplake/hivemind 0.7.60 → 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.60"
+    "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.60",
+      "version": "0.7.61",
       "source": {
         "source": "git-subdir",
         "url": "https://github.com/activeloopai/hivemind.git",
         "path": "claude-code",
-        "sha": "16a718fb94219d96ad5686ca414504d694643bc9"
+        "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.60",
+  "version": "0.7.61",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/openclaw/dist/index.js

@@ -1795,7 +1795,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.60".length > 0 ? "0.7.60" : null;
+  return "0.7.61".length > 0 ? "0.7.61" : 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.60"
+  "version": "0.7.61"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.60",
+  "version": "0.7.61",
   "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.60",
+  "version": "0.7.61",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {
@@ -26,6 +26,7 @@
     "openclaw/openclaw.plugin.json",
     "openclaw/package.json",
     ".claude-plugin",
+    "scripts",
     "README.md",
     "LICENSE"
   ],

package/scripts/audit-openclaw-bundle.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Local replication of ClawHub's static-analysis scanner against the openclaw
+ * plugin bundle. Runs the same per-file regex rules ClawHub uses at publish
+ * time so we can see flags BEFORE shipping a release instead of after.
+ *
+ * Rules are replicated (not imported) from openclaw's skill-scanner — that
+ * code lives in our research-reference checkout under ~/al-projects/ext/ and
+ * is third-party we don't own. Re-sync these rules if upstream changes them.
+ *
+ *   Reference: openclaw repo, src/security/skill-scanner.ts:147-206
+ *
+ * Usage:
+ *   node scripts/audit-openclaw-bundle.mjs           # scan openclaw/dist
+ *   node scripts/audit-openclaw-bundle.mjs <path>    # scan a specific dir
+ *
+ * Exits non-zero if any "critical" or "warn" finding is reported.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, extname } from "node:path";
+
+// Parse args: positional SCAN_DIR + optional --criticals-only flag.
+//
+// --criticals-only exits non-zero only on `critical` findings, treating
+// `warn` as advisory. Used by the CI release gate so we block on
+// definitively-malicious patterns but tolerate fundamental warns like
+// the worker's "readFileSync + fetch in same file" — irreducible without
+// splitting the worker into multiple shipped files. Local dev still
+// runs with the default strict mode (exits on any finding) so we
+// surface every drift before it ships.
+const rawArgs = process.argv.slice(2);
+const STRICT_MODE = !rawArgs.includes("--criticals-only");
+const SCAN_DIR = rawArgs.find(a => !a.startsWith("--")) ?? "openclaw/dist";
+const SCANNABLE_EXT = new Set([".js", ".mjs", ".cjs"]);
+const MAX_FILE_BYTES = 1024 * 1024; // 1MB; matches upstream default
+
+// ---- LINE_RULES (per-line; both pattern AND requiresContext must match) ----
+const LINE_RULES = [
+  {
+    ruleId: "dangerous-exec",
+    severity: "critical",
+    message: "Shell command execution detected (child_process)",
+    pattern: /\b(exec|execSync|spawn|spawnSync|execFile|execFileSync)\s*\(/,
+    requiresContext: /child_process/,
+  },
+  {
+    ruleId: "dynamic-code-execution",
+    severity: "critical",
+    message: "Dynamic code execution detected",
+    pattern: /\beval\s*\(|new\s+Function\s*\(/,
+  },
+  {
+    ruleId: "crypto-mining",
+    severity: "critical",
+    message: "Possible crypto-mining reference detected",
+    pattern: /stratum\+tcp|stratum\+ssl|coinhive|cryptonight|xmrig/i,
+  },
+  {
+    ruleId: "suspicious-network",
+    severity: "warn",
+    message: "WebSocket connection to non-standard port",
+    pattern: /new\s+WebSocket\s*\(\s*["']wss?:\/\/[^"']*:(\d+)/,
+    portCheck: true,
+  },
+];
+
+const STANDARD_PORTS = new Set([80, 443, 8080, 8443, 3000]);
+const NETWORK_SEND = /\bfetch\s*\(|\bpost\s*\(|\.\s*post\s*\(|http\.request\s*\(/i;
+
+// ---- SOURCE_RULES (whole file; both pattern AND requiresContext must match) ----
+const SOURCE_RULES = [
+  {
+    ruleId: "potential-exfiltration",
+    severity: "warn",
+    message: "File read combined with network send (possible exfiltration)",
+    pattern: /readFileSync|readFile/,
+    requiresContext: NETWORK_SEND,
+  },
+  {
+    ruleId: "obfuscated-code-hex",
+    severity: "warn",
+    message: "Hex-encoded string sequence detected (possible obfuscation)",
+    pattern: /(\\x[0-9a-fA-F]{2}){6,}/,
+  },
+  {
+    ruleId: "obfuscated-code-base64",
+    severity: "warn",
+    message: "Large base64 payload with decode call detected (possible obfuscation)",
+    pattern: /(?:atob|Buffer\.from)\s*\(\s*["'][A-Za-z0-9+/=]{200,}["']/,
+  },
+  {
+    ruleId: "env-harvesting",
+    severity: "critical",
+    message: "Environment variable access combined with network send (possible credential harvesting)",
+    pattern: /process\.env/,
+    requiresContext: NETWORK_SEND,
+  },
+];
+
+function truncate(s, n = 120) { return s.length <= n ? s : s.slice(0, n) + "…"; }
+
+function scanFile(path) {
+  const stat = statSync(path);
+  if (stat.size > MAX_FILE_BYTES) {
+    return [{ ruleId: "file-too-large", severity: "info", file: path, line: 0, message: `Skipped (${stat.size} bytes > ${MAX_FILE_BYTES} byte limit)`, evidence: "" }];
+  }
+  const source = readFileSync(path, "utf-8");
+  const lines = source.split("\n");
+  const findings = [];
+
+  for (const rule of LINE_RULES) {
+    if (rule.requiresContext && !rule.requiresContext.test(source)) continue;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const m = rule.pattern.exec(line);
+      if (!m) continue;
+      if (rule.portCheck) {
+        const port = Number.parseInt(m[1], 10);
+        if (STANDARD_PORTS.has(port)) continue;
+      }
+      findings.push({ ruleId: rule.ruleId, severity: rule.severity, file: path, line: i + 1, message: rule.message, evidence: truncate(line.trim()) });
+      break; // one finding per line-rule per file
+    }
+  }
+
+  for (const rule of SOURCE_RULES) {
+    if (!rule.pattern.test(source)) continue;
+    if (rule.requiresContext && !rule.requiresContext.test(source)) continue;
+    let matchLine = 0, matchEvidence = "";
+    for (let i = 0; i < lines.length; i++) {
+      if (rule.pattern.test(lines[i])) { matchLine = i + 1; matchEvidence = lines[i].trim(); break; }
+    }
+    if (matchLine === 0) { matchLine = 1; matchEvidence = source.slice(0, 120); }
+    findings.push({ ruleId: rule.ruleId, severity: rule.severity, file: path, line: matchLine, message: rule.message, evidence: truncate(matchEvidence) });
+  }
+
+  return findings;
+}
+
+async function* walk(dir) {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) yield* walk(p);
+    else if (entry.isFile() && SCANNABLE_EXT.has(extname(entry.name).toLowerCase())) yield p;
+  }
+}
+
+const SEVERITY_RANK = { info: 0, warn: 1, critical: 2 };
+const SEVERITY_ICON = { info: "·", warn: "!", critical: "✗" };
+
+const allFindings = [];
+let scannedFiles = 0;
+for await (const file of walk(SCAN_DIR)) {
+  scannedFiles++;
+  for (const f of scanFile(file)) allFindings.push(f);
+}
+
+const counts = { info: 0, warn: 0, critical: 0 };
+for (const f of allFindings) counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+
+console.log(`\nScanned ${scannedFiles} file(s) under ${SCAN_DIR}/\n`);
+
+if (allFindings.length === 0) {
+  console.log("✓ No findings. Bundle is clean against ClawHub's static-analysis rules.\n");
+  process.exit(0);
+}
+
+allFindings.sort((a, b) => (SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]) || a.file.localeCompare(b.file) || a.line - b.line);
+for (const f of allFindings) {
+  console.log(`${SEVERITY_ICON[f.severity]} [${f.severity.toUpperCase()}] ${f.ruleId}`);
+  console.log(`    ${f.file}:${f.line}`);
+  console.log(`    ${f.message}`);
+  if (f.evidence) console.log(`    > ${f.evidence}`);
+  console.log();
+}
+
+const summary = `${counts.critical} critical, ${counts.warn} warn, ${counts.info} info`;
+console.log(`Summary: ${summary}\n`);
+if (!STRICT_MODE && counts.critical === 0 && counts.warn > 0) {
+  console.log(`(--criticals-only: warns are advisory and do NOT block. Re-run without the flag for strict local checks.)\n`);
+}
+const shouldFail = STRICT_MODE
+  ? (counts.critical > 0 || counts.warn > 0)
+  : counts.critical > 0;
+process.exit(shouldFail ? 1 : 0);

package/scripts/ensure-tree-sitter.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Ensures the native tree-sitter bindings are loadable on this platform / Node ABI.
+//
+// Why this exists: tree-sitter@0.21.x ships no linux-arm64 prebuild, and
+// tree-sitter-typescript@0.23.x ships a mislabeled (x86-64) one. On linux-arm64
+// both must be compiled from source, and under Node >=22 that compile requires C++20
+// (tree-sitter@0.21's binding.gyp does not request it). tree-sitter is declared as an
+// optionalDependency so this expected arm64 build failure does not abort `npm install`;
+// this script then heals it afterwards.
+//
+// On platforms where the shipped prebuilds work (x64 / darwin / CI) this is a fast
+// no-op and never touches anything. It is intentionally non-fatal: if no toolchain is
+// available it warns and exits 0 rather than breaking the install.
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const ROOT = process.cwd();
+const require = createRequire(`${ROOT}/`);
+const PKGS = ['tree-sitter', 'tree-sitter-typescript'];
+
+function bindingsLoad() {
+  try {
+    const Parser = require('tree-sitter');
+    const TS = require('tree-sitter-typescript').typescript;
+    const parser = new Parser();
+    parser.setLanguage(TS);
+    parser.parse('const x = 1;');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (process.env.ENSURE_TS_RUNNING) process.exit(0); // recursion guard for the nested npm calls below
+if (bindingsLoad()) process.exit(0); // healthy prebuild / prior build → nothing to do
+
+console.error('[ensure-tree-sitter] native bindings not loadable on this platform — building from source...');
+
+const pkg = JSON.parse(readFileSync(`${ROOT}/package.json`, 'utf8'));
+const declared = { ...pkg.dependencies, ...pkg.optionalDependencies };
+
+const env = { ...process.env, ENSURE_TS_RUNNING: '1' };
+if (process.platform !== 'win32') {
+  // Node >=22 V8 headers require C++20; tree-sitter@0.21's binding.gyp doesn't request it.
+  env.CXXFLAGS = `${process.env.CXXFLAGS ?? ''} -std=c++20`.trim();
+}
+const run = (cmd) => execSync(cmd, { stdio: 'inherit', env, cwd: ROOT });
+
+try {
+  // 1. Re-fetch any package npm dropped — an optional dependency whose build failed is
+  //    removed from node_modules. --ignore-scripts: fetch only, so the compile below is
+  //    the single source of truth and the project build isn't triggered prematurely.
+  const missing = PKGS.filter((n) => !existsSync(`${ROOT}/node_modules/${n}/package.json`));
+  if (missing.length) {
+    const specs = missing.map((n) => `${n}@${declared[n] ?? 'latest'}`);
+    run(`npm install ${specs.join(' ')} --no-save --ignore-scripts`);
+  }
+
+  // 2. Force a from-source compile. These packages install via node-gyp-build, which uses
+  //    a local prebuild when present and otherwise compiles from source — no network. By
+  //    removing the (absent or wrong-arch) prebuilds plus any stale build, the rebuild is
+  //    guaranteed to compile locally, and node-gyp-build loads build/Release ahead of
+  //    prebuilds, so the correct binary always wins.
+  for (const n of PKGS) {
+    rmSync(`${ROOT}/node_modules/${n}/prebuilds`, { recursive: true, force: true });
+    rmSync(`${ROOT}/node_modules/${n}/build`, { recursive: true, force: true });
+  }
+  run(`npm rebuild ${PKGS.join(' ')}`);
+} catch (err) {
+  console.error('[ensure-tree-sitter] rebuild command failed:', err.message);
+}
+
+if (bindingsLoad()) {
+  console.error('[ensure-tree-sitter] OK — bindings compiled from source and loadable.');
+  process.exit(0);
+}
+
+// Strict mode: turn the warning into a hard failure. Opt-in via
+// HIVEMIND_STRICT_POSTINSTALL=1 — set by this repo's own CI workflows so a
+// heal failure surfaces as a red check on the PR instead of getting swallowed
+// and re-emerging downstream as `tsc: Cannot find module 'tree-sitter'`.
+// Default stays non-fatal so end-user consumers of @deeplake/hivemind never
+// get a hard install break — the runtime check at use-time is enough for them.
+const strict = process.env.HIVEMIND_STRICT_POSTINSTALL === '1';
+console.error(
+  '[ensure-tree-sitter] WARNING: tree-sitter bindings still unavailable. ' +
+    'Install a C/C++ toolchain and re-run `npm run rebuild:native`.' +
+    (strict ? ' (strict mode — failing this install)' : ' (non-fatal)'),
+);
+process.exit(strict ? 1 : 0);

package/scripts/pack-check.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Refuse a publish if `npm pack` would include filenames that should
+// never ship to npm — credentials, CI workflows, git internals.
+// Catches a future PR widening package.json's `files` array (or
+// switching to a permissive .npmignore) before any token is touched.
+
+import { execFileSync } from 'node:child_process';
+
+const FORBIDDEN = [
+  /(^|\/)\.npmrc$/,
+  /(^|\/)\.env($|\.)/,
+  /(^|\/)secrets?(\/|$)/,
+  /(^|\/)\.github(\/|$)/,
+  /(^|\/)\.git(\/|$)/,
+];
+
+const raw = execFileSync('npm', ['pack', '--dry-run', '--json'], {
+  encoding: 'utf8',
+  stdio: ['ignore', 'pipe', 'inherit'],
+});
+const entries = JSON.parse(raw)[0].files.map((f) => f.path);
+const hits = entries.filter((p) => FORBIDDEN.some((rx) => rx.test(p)));
+
+if (hits.length) {
+  console.error('Refusing to publish — forbidden filenames in tarball:');
+  for (const h of hits) console.error('  ' + h);
+  process.exit(1);
+}
+console.log(`pack-check OK — ${entries.length} files, no forbidden patterns`);

package/scripts/sync-versions.d.mts

@@ -0,0 +1,15 @@
+export declare const SCALAR_TARGETS: readonly string[];
+export declare const MARKETPLACE_PATH: string;
+
+export interface SyncResult {
+  writes: number;
+  skips: number;
+  version: string;
+}
+
+export interface SyncOptions {
+  root?: string;
+  log?: (msg: string) => void;
+}
+
+export declare function syncVersions(opts?: SyncOptions): SyncResult;

package/scripts/sync-versions.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// Sync the version field across all manifests from the single source-of-truth
+// in package.json. Runs as a `prebuild` hook so esbuild's version-define
+// inlines the same value into bundles.
+//
+// Idempotent: skips writes when a target already matches.
+// Exits non-zero if any target file is missing or if package.json has no version.
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SOURCE = "package.json";
+
+// Scalar targets: each has a single top-level `version` field tracking package.json.
+export const SCALAR_TARGETS = [
+  ".claude-plugin/plugin.json",
+  "claude-code/.claude-plugin/plugin.json",
+  "openclaw/openclaw.plugin.json",
+  "openclaw/package.json",
+  "codex/package.json",
+];
+
+// Marketplace target: has BOTH metadata.version AND every plugins[].version.
+export const MARKETPLACE_PATH = ".claude-plugin/marketplace.json";
+
+function readJsonAt(root, relPath) {
+  const full = resolve(root, relPath);
+  if (!existsSync(full)) {
+    throw new Error(`sync-versions: missing target ${relPath}`);
+  }
+  return JSON.parse(readFileSync(full, "utf-8"));
+}
+
+function writeJsonAt(root, relPath, obj) {
+  writeFileSync(resolve(root, relPath), JSON.stringify(obj, null, 2) + "\n");
+}
+
+export function syncVersions({ root = process.cwd(), log = (m) => console.error(m) } = {}) {
+  const source = readJsonAt(root, SOURCE);
+  const version = source.version;
+  if (!version || typeof version !== "string") {
+    throw new Error(`sync-versions: ${SOURCE} has no string \`version\` field`);
+  }
+
+  let writes = 0;
+  let skips = 0;
+
+  for (const target of SCALAR_TARGETS) {
+    const data = readJsonAt(root, target);
+    if (data.version === version) {
+      log(`sync-versions: ${target} already at ${version}`);
+      skips++;
+      continue;
+    }
+    const old = data.version;
+    data.version = version;
+    writeJsonAt(root, target, data);
+    log(`sync-versions: ${target}: ${old} -> ${version}`);
+    writes++;
+  }
+
+  const marketplace = readJsonAt(root, MARKETPLACE_PATH);
+  let mpChanged = false;
+  if (marketplace.metadata?.version !== version) {
+    const old = marketplace.metadata?.version;
+    marketplace.metadata = marketplace.metadata || {};
+    marketplace.metadata.version = version;
+    log(`sync-versions: ${MARKETPLACE_PATH} metadata.version: ${old} -> ${version}`);
+    mpChanged = true;
+  }
+  if (Array.isArray(marketplace.plugins)) {
+    for (const plugin of marketplace.plugins) {
+      if (plugin.version !== version) {
+        const old = plugin.version;
+        plugin.version = version;
+        log(`sync-versions: ${MARKETPLACE_PATH} plugins[${plugin.name}].version: ${old} -> ${version}`);
+        mpChanged = true;
+      }
+    }
+  }
+  if (mpChanged) {
+    writeJsonAt(root, MARKETPLACE_PATH, marketplace);
+    writes++;
+  } else {
+    log(`sync-versions: ${MARKETPLACE_PATH} already at ${version}`);
+    skips++;
+  }
+
+  log(`sync-versions: ${writes} written, ${skips} unchanged`);
+  return { writes, skips, version };
+}
+
+// Script mode — only runs when invoked directly, not when imported by tests.
+const __entryUrl = process.argv[1] ? fileURLToPath(import.meta.url) === resolve(process.argv[1]) : false;
+if (__entryUrl) {
+  try {
+    syncVersions();
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+}

package/scripts/verify-install.sh

@@ -0,0 +1,218 @@
+#!/usr/bin/env bash
+# Hivemind install verifier — sanity-checks each of the 9 agent integrations.
+#
+# Run this after `npx -y @deeplake/hivemind install`. It checks file
+# placement, config schema, dry-invokes hook scripts, and exercises the
+# MCP server against its initialize handshake. Doesn't require any agent
+# to actually be running — just verifies our installer's footprint.
+#
+# Exits 0 if everything we installed is healthy; 1 if any agent fails.
+# Skips agents whose marker dir doesn't exist (you don't have them).
+#
+# Usage:
+#   bash scripts/verify-install.sh
+#   curl -sSL https://raw.githubusercontent.com/activeloopai/hivemind/main/scripts/verify-install.sh | bash
+
+set -u
+
+PASS=0
+FAIL=0
+SKIP=0
+
+green() { printf "\033[0;32m%s\033[0m" "$1"; }
+red()   { printf "\033[0;31m%s\033[0m" "$1"; }
+gray()  { printf "\033[0;90m%s\033[0m" "$1"; }
+yellow(){ printf "\033[0;33m%s\033[0m" "$1"; }
+
+ok()   { echo "  $(green PASS) $1"; PASS=$((PASS+1)); }
+bad()  { echo "  $(red FAIL) $1${2:+ — $2}"; FAIL=$((FAIL+1)); }
+skip() { echo "  $(gray SKIP) $1${2:+ — $2}"; SKIP=$((SKIP+1)); }
+
+section() { echo; echo "$(yellow "▎ $1")"; }
+
+require_jq() {
+  command -v jq >/dev/null 2>&1 || {
+    echo "$(red "fatal:") jq not found on PATH (install jq for this script to run)" >&2
+    exit 2
+  }
+}
+require_jq
+
+# ───────────────────────────────────────────────────────────────────────
+# Claude Code — marketplace plugin
+section "Claude Code"
+if [ -d "$HOME/.claude" ]; then
+  if command -v claude >/dev/null 2>&1; then
+    if claude plugin list 2>/dev/null | grep -q "hivemind@hivemind"; then
+      ok "claude plugin list shows hivemind@hivemind"
+      if claude plugin list 2>/dev/null | grep -q "✔ enabled"; then
+        ok "plugin enabled"
+      else
+        bad "plugin not enabled" "run: claude plugin enable hivemind@hivemind"
+      fi
+    else
+      bad "claude plugin list does not show hivemind@hivemind" "rerun: hivemind claude install"
+    fi
+  else
+    bad "claude CLI not found on PATH" "Claude Code is not installed correctly"
+  fi
+else
+  skip "Claude Code" "no ~/.claude"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# Codex — ~/.codex/hooks.json + bundle
+section "Codex"
+if [ -d "$HOME/.codex" ]; then
+  HOOKS="$HOME/.codex/hooks.json"
+  if [ -f "$HOOKS" ]; then
+    if jq -e '.hooks.SessionStart' "$HOOKS" >/dev/null 2>&1; then
+      ok "$HOOKS has SessionStart"
+    else
+      bad "$HOOKS missing SessionStart"
+    fi
+  else
+    bad "$HOOKS not found" "rerun: hivemind codex install"
+  fi
+  if [ -x "$HOME/.codex/hivemind/bundle/session-start.js" ]; then
+    ok "session-start.js executable"
+  else
+    bad "session-start.js missing or not executable"
+  fi
+else
+  skip "Codex" "no ~/.codex"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# OpenClaw — ~/.openclaw/extensions/hivemind/
+section "OpenClaw"
+if [ -d "$HOME/.openclaw" ]; then
+  EXT="$HOME/.openclaw/extensions/hivemind"
+  if [ -f "$EXT/openclaw.plugin.json" ]; then
+    ok "openclaw.plugin.json present"
+    if jq -e '.contracts.tools' "$EXT/openclaw.plugin.json" >/dev/null 2>&1; then
+      ok "manifest declares contracts.tools"
+    else
+      bad "manifest missing contracts.tools (stale install)"
+    fi
+  else
+    bad "$EXT/openclaw.plugin.json not found" "rerun: hivemind claw install"
+  fi
+  [ -f "$EXT/dist/index.js" ] && ok "dist/index.js present" || bad "dist/index.js not found"
+else
+  skip "OpenClaw" "no ~/.openclaw"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# Cursor — ~/.cursor/hooks.json (1.7+ schema)
+section "Cursor"
+if [ -d "$HOME/.cursor" ]; then
+  HOOKS="$HOME/.cursor/hooks.json"
+  if [ -f "$HOOKS" ]; then
+    for ev in sessionStart beforeSubmitPrompt postToolUse afterAgentResponse stop sessionEnd; do
+      if jq -e ".hooks.$ev[0].command" "$HOOKS" >/dev/null 2>&1; then
+        ok "hooks.$ev wired"
+      else
+        bad "hooks.$ev missing" "rerun: hivemind cursor install"
+      fi
+    done
+    # Dry-invoke session-start.js
+    payload='{"hook_event_name":"sessionStart","session_id":"verify","conversation_id":"verify","workspace_roots":["/tmp"]}'
+    if echo "$payload" | timeout 5 node "$HOME/.cursor/hivemind/bundle/session-start.js" 2>/dev/null | jq -e '.additional_context' >/dev/null 2>&1; then
+      ok "session-start.js produces valid additional_context JSON"
+    else
+      bad "session-start.js dry-invoke did not return additional_context"
+    fi
+  else
+    bad "$HOOKS not found" "rerun: hivemind cursor install"
+  fi
+else
+  skip "Cursor" "no ~/.cursor"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# Hermes Agent — skill drop
+section "Hermes Agent"
+if [ -d "$HOME/.hermes" ]; then
+  SKILL="$HOME/.hermes/skills/hivemind-memory/SKILL.md"
+  if [ -f "$SKILL" ]; then
+    ok "SKILL.md present at $SKILL"
+    if grep -q "Hivemind Memory" "$SKILL"; then
+      ok "skill content looks right"
+    else
+      bad "skill content missing 'Hivemind Memory' header"
+    fi
+  else
+    bad "$SKILL not found" "rerun: hivemind hermes install"
+  fi
+else
+  skip "Hermes Agent" "no ~/.hermes"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# pi — AGENTS.md + extension
+# No per-agent SKILL.md: pi reads skills from both ~/.pi/agent/skills/ AND
+# ~/.agents/skills/ (the agentskills.io shared dir), so dropping a local
+# skill would collide with the codex installer's shared symlink. AGENTS.md
+# (auto-loaded every turn) plus the registered hivemind tools cover the
+# action surface; see install-pi.ts for the rationale.
+section "pi"
+if [ -d "$HOME/.pi" ]; then
+  AGENTS="$HOME/.pi/agent/AGENTS.md"
+  if [ -f "$AGENTS" ] && grep -q "BEGIN hivemind-memory" "$AGENTS"; then
+    ok "AGENTS.md has BEGIN hivemind-memory marker"
+  else
+    bad "AGENTS.md missing hivemind block" "rerun: hivemind pi install"
+  fi
+  EXT="$HOME/.pi/agent/extensions/hivemind.ts"
+  if [ -f "$EXT" ]; then
+    ok "extension installed at $EXT"
+    # Sanity-check that key surfaces are wired in the installed extension.
+    if grep -q "registerTool" "$EXT" && grep -q "hivemind_search" "$EXT" && \
+       grep -q "hivemind_read" "$EXT" && grep -q "hivemind_index" "$EXT"; then
+      ok "extension registers hivemind_search / hivemind_read / hivemind_index"
+    else
+      bad "extension missing one or more hivemind_* tool registrations"
+    fi
+    if grep -q 'pi.on("tool_result"' "$EXT" && grep -q 'pi.on("input"' "$EXT"; then
+      ok "extension subscribes to input + tool_result for autocapture"
+    else
+      bad "extension missing input/tool_result subscriptions"
+    fi
+  else
+    bad "$EXT not found" "rerun: hivemind pi install"
+  fi
+else
+  skip "pi" "no ~/.pi"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+# MCP server (used by Hermes; reused by any future MCP-aware client).
+section "Hivemind MCP server"
+SERVER="$HOME/.hivemind/mcp/server.js"
+if [ -f "$SERVER" ]; then
+  ok "server.js installed at $SERVER"
+  # Initialize + tools/list handshake. Expect "hivemind_search" in response.
+  init='{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"verify","version":"1.0"}}}'
+  inited='{"jsonrpc":"2.0","method":"notifications/initialized"}'
+  list='{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
+  resp=$( ( printf '%s\n%s\n%s\n' "$init" "$inited" "$list"; sleep 1 ) | timeout 8 node "$SERVER" 2>/dev/null )
+  if echo "$resp" | grep -q '"hivemind_search"'; then
+    ok "tools/list returns hivemind_search / hivemind_read / hivemind_index"
+  else
+    bad "MCP server did not list expected tools" "check ~/.deeplake/credentials.json"
+  fi
+else
+  skip "MCP server" "no ~/.hivemind/mcp/server.js (no MCP-aware agent installed yet)"
+fi
+
+# ───────────────────────────────────────────────────────────────────────
+echo
+echo "$(yellow "▎ Summary")"
+echo "  $(green PASS): $PASS"
+echo "  $(red  FAIL): $FAIL"
+echo "  $(gray SKIP): $SKIP (agent not present on this machine)"
+echo
+
+if [ "$FAIL" -gt 0 ]; then exit 1; fi
+exit 0