@deeplake/hivemind 0.7.34 → 0.7.35

package/.claude-plugin/marketplace.json

@@ -6,13 +6,13 @@
   },
   "metadata": {
     "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
-    "version": "0.7.34"
+    "version": "0.7.35"
   },
   "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.34",
+      "version": "0.7.35",
       "source": "./claude-code",
       "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.34",
+  "version": "0.7.35",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/openclaw/dist/index.js

@@ -4,6 +4,10 @@ import {
   saveCredentials
 } from "./chunks/chunk-OSD5GJJ5.js";
 
+// stub:node:child_process
+var spawn = () => {
+};
+
 // src/utils/client-header.ts
 var DEEPLAKE_CLIENT_HEADER = "X-Deeplake-Client";
 function deeplakeClientValue() {
@@ -1153,10 +1157,232 @@ async function readVirtualPathContent(api2, memoryTable2, sessionsTable2, virtua
   return (await readVirtualPathContents(api2, memoryTable2, sessionsTable2, [virtualPath])).get(virtualPath) ?? null;
 }
 
+// src/embeddings/standalone-embed-client.ts
+import { connect } from "node:net";
+import {
+  openSync as openSync2,
+  closeSync as closeSync2,
+  writeSync,
+  unlinkSync as unlinkSync2,
+  existsSync,
+  readFileSync as readFileSync2
+} from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/embeddings/protocol.ts
+var DEFAULT_SOCKET_DIR = "/tmp";
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_CLIENT_TIMEOUT_MS = 2e3;
+function socketPathFor(uid, dir = DEFAULT_SOCKET_DIR) {
+  return `${dir}/hivemind-embed-${uid}.sock`;
+}
+function pidPathFor(uid, dir = DEFAULT_SOCKET_DIR) {
+  return `${dir}/hivemind-embed-${uid}.pid`;
+}
+
+// src/embeddings/standalone-embed-client.ts
+var SHARED_DAEMON_PATH = join3(homedir3(), ".hivemind", "embed-deps", "embed-daemon.js");
+var _spawn = spawn;
+function getUid() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  return uid !== void 0 ? String(uid) : "default";
+}
+function isPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readPidFile(path) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf-8").trim();
+  } catch {
+    return null;
+  }
+  if (raw === "") return "empty";
+  const pid = Number(raw);
+  if (!pid || Number.isNaN(pid)) return null;
+  return pid;
+}
+function connectOnce(socketPath, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const sock = connect(socketPath);
+    const to = setTimeout(() => {
+      sock.destroy();
+      reject(new Error("connect timeout"));
+    }, timeoutMs);
+    sock.once("connect", () => {
+      clearTimeout(to);
+      resolve2(sock);
+    });
+    sock.once("error", (e) => {
+      clearTimeout(to);
+      reject(e);
+    });
+  });
+}
+function sendAndWait(sock, req, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    let buf = "";
+    const to = setTimeout(() => {
+      sock.destroy();
+      reject(new Error("request timeout"));
+    }, timeoutMs);
+    sock.setEncoding("utf-8");
+    sock.on("data", (chunk) => {
+      buf += chunk;
+      const nl = buf.indexOf("\n");
+      if (nl === -1) return;
+      clearTimeout(to);
+      try {
+        resolve2(JSON.parse(buf.slice(0, nl)));
+      } catch (e) {
+        reject(e);
+      }
+    });
+    sock.on("error", (e) => {
+      clearTimeout(to);
+      reject(e);
+    });
+    sock.on("end", () => {
+      clearTimeout(to);
+      reject(new Error("connection closed without response"));
+    });
+    sock.write(JSON.stringify(req) + "\n");
+  });
+}
+function trySpawnDaemon(daemonEntry, pidPath) {
+  let fd;
+  try {
+    fd = openSync2(pidPath, "wx", 384);
+    writeSync(fd, String(process.pid));
+  } catch {
+    const existing = readPidFile(pidPath);
+    if (existing === "empty") return false;
+    if (existing !== null && isPidAlive(existing)) {
+      return false;
+    }
+    try {
+      unlinkSync2(pidPath);
+    } catch {
+    }
+    try {
+      fd = openSync2(pidPath, "wx", 384);
+      writeSync(fd, String(process.pid));
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const child = _spawn(process.execPath, [daemonEntry], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return true;
+  } catch {
+    try {
+      unlinkSync2(pidPath);
+    } catch {
+    }
+    return false;
+  } finally {
+    try {
+      closeSync2(fd);
+    } catch {
+    }
+  }
+}
+function maybeCleanupOwnPlaceholder(pidPath) {
+  const existing = readPidFile(pidPath);
+  if (existing === process.pid || existing === "empty") {
+    try {
+      unlinkSync2(pidPath);
+    } catch {
+    }
+  }
+}
+async function waitForSocket(socketPath, deadline, connectTimeoutMs) {
+  let delay = 30;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, delay));
+    delay = Math.min(delay * 1.5, 300);
+    if (!existsSync(socketPath)) continue;
+    try {
+      return await connectOnce(socketPath, connectTimeoutMs);
+    } catch {
+    }
+  }
+  return null;
+}
+async function tryEmbedStandalone(text, kind, opts = {}) {
+  const socketDir = opts.socketDir ?? "/tmp";
+  const daemonEntry = opts.daemonEntry ?? SHARED_DAEMON_PATH;
+  const requestTimeoutMs = opts.requestTimeoutMs ?? DEFAULT_CLIENT_TIMEOUT_MS;
+  const spawnWaitMs = opts.spawnWaitMs ?? 5e3;
+  const uid = getUid();
+  const socketPath = socketPathFor(uid, socketDir);
+  const pidPath = pidPathFor(uid, socketDir);
+  let sock = null;
+  try {
+    sock = await connectOnce(socketPath, requestTimeoutMs);
+  } catch {
+  }
+  if (!sock) {
+    if (!existsSync(daemonEntry)) {
+      return null;
+    }
+    trySpawnDaemon(daemonEntry, pidPath);
+    const deadline = Date.now() + spawnWaitMs;
+    sock = await waitForSocket(socketPath, deadline, requestTimeoutMs);
+    if (!sock) {
+      maybeCleanupOwnPlaceholder(pidPath);
+      return null;
+    }
+  }
+  try {
+    const req = { op: "embed", id: "1", kind, text };
+    const resp = await sendAndWait(sock, req, requestTimeoutMs);
+    if (resp.error || !resp.embedding || !Array.isArray(resp.embedding)) {
+      return null;
+    }
+    for (const v of resp.embedding) {
+      if (typeof v !== "number" || !Number.isFinite(v)) return null;
+    }
+    return resp.embedding;
+  } catch {
+    return null;
+  } finally {
+    try {
+      sock.end();
+    } catch {
+    }
+  }
+}
+function _setSpawnImpl(fn) {
+  _spawn = fn ?? spawn;
+}
+
+// src/embeddings/sql.ts
+function embeddingSqlLiteral(vec) {
+  if (!vec || vec.length === 0) return "NULL";
+  const parts = [];
+  for (const v of vec) {
+    if (!Number.isFinite(v)) return "NULL";
+    parts.push(String(v));
+  }
+  return `ARRAY[${parts.join(",")}]::float4[]`;
+}
+
 // openclaw/src/index.ts
 import { fileURLToPath } from "node:url";
 import { join as joinPath, dirname as dirnamePath } from "node:path";
-import { homedir as homedir3, tmpdir } from "node:os";
+import { homedir as homedir4, tmpdir } from "node:os";
 import {
   existsSync as fsExists,
   mkdirSync as fsMkdir,
@@ -1202,6 +1428,7 @@ async function loadConfig() {
 }
 var requireFromOpenclaw = createRequire(import.meta.url);
 var { spawn: realSpawn, execFileSync: realExecFileSync } = requireFromOpenclaw("node:child_process");
+_setSpawnImpl(realSpawn);
 var inheritedEnv = process;
 function applyOpenclawTuning(pluginConfig) {
   const cfg = pluginConfig ?? {};
@@ -1239,7 +1466,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.34".length > 0 ? "0.7.34" : null;
+  return "0.7.35".length > 0 ? "0.7.35" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);
@@ -1346,8 +1573,8 @@ var skillifySpawnedFor = /* @__PURE__ */ new Set();
 var __openclaw_filename = fileURLToPath(import.meta.url);
 var __openclaw_dirname = dirnamePath(__openclaw_filename);
 var OPENCLAW_SKILLIFY_WORKER_PATH = joinPath(__openclaw_dirname, "skillify-worker.js");
-var OPENCLAW_SKILLIFY_STATE_DIR = joinPath(homedir3(), ".deeplake", "state", "skillify");
-var OPENCLAW_SKILLIFY_LEGACY_STATE_DIR = joinPath(homedir3(), ".deeplake", "state", "skilify");
+var OPENCLAW_SKILLIFY_STATE_DIR = joinPath(homedir4(), ".deeplake", "state", "skillify");
+var OPENCLAW_SKILLIFY_LEGACY_STATE_DIR = joinPath(homedir4(), ".deeplake", "state", "skilify");
 var openclawSkillifyMigrationAttempted = false;
 function migrateOpenclawSkillifyLegacyStateDir() {
   if (openclawSkillifyMigrationAttempted) return;
@@ -1463,7 +1690,7 @@ function spawnOpenclawSkillifyWorker(a) {
     sessionsTable,
     skillsTable,
     userName: a.userName,
-    cwd: homedir3(),
+    cwd: homedir4(),
     // sentinel — only used by worker if install=project
     projectKey,
     project,
@@ -1479,7 +1706,7 @@ function spawnOpenclawSkillifyWorker(a) {
     cursorModel: void 0,
     hermesProvider: void 0,
     hermesModel: void 0,
-    skillifyLog: joinPath(homedir3(), ".deeplake", "hivemind-openclaw-skillify.log"),
+    skillifyLog: joinPath(homedir4(), ".deeplake", "hivemind-openclaw-skillify.log"),
     currentSessionId: a.sessionId,
     // Pass the tuning dispatch through so the worker can repopulate its
     // own globalThis (each process has its own globalThis). The worker
@@ -2018,7 +2245,9 @@ One brain for every agent on your team.
                 };
                 const line = JSON.stringify(entry);
                 const jsonForSql = line.replace(/'/g, "''");
-                const insertSql = `INSERT INTO "${sessionsTable}" (id, path, filename, message, author, size_bytes, project, description, agent, plugin_version, creation_date, last_update_date) VALUES ('${crypto.randomUUID()}', '${sqlStr(sessionPath)}', '${sqlStr(filename)}', '${jsonForSql}'::jsonb, '${sqlStr(cfg.userName)}', ${Buffer.byteLength(line, "utf-8")}, '${sqlStr(projectName)}', '${sqlStr(msg.role)}', 'openclaw', '${sqlStr(getInstalledVersion() ?? "")}', '${ts}', '${ts}')`;
+                const embedding = await tryEmbedStandalone(line, "document");
+                const embeddingSql = embeddingSqlLiteral(embedding);
+                const insertSql = `INSERT INTO "${sessionsTable}" (id, path, filename, message, message_embedding, author, size_bytes, project, description, agent, plugin_version, creation_date, last_update_date) VALUES ('${crypto.randomUUID()}', '${sqlStr(sessionPath)}', '${sqlStr(filename)}', '${jsonForSql}'::jsonb, ${embeddingSql}, '${sqlStr(cfg.userName)}', ${Buffer.byteLength(line, "utf-8")}, '${sqlStr(projectName)}', '${sqlStr(msg.role)}', 'openclaw', '${sqlStr(getInstalledVersion() ?? "")}', '${ts}', '${ts}')`;
                 try {
                   await dl.query(insertSql);
                 } catch (e) {

package/openclaw/openclaw.plugin.json

@@ -52,5 +52,5 @@
       }
     }
   },
-  "version": "0.7.34"
+  "version": "0.7.35"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.34",
+  "version": "0.7.35",
   "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.34",
+  "version": "0.7.35",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {

package/pi/extension-source/hivemind.ts

@@ -26,7 +26,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import {
   readFileSync, existsSync, appendFileSync, mkdirSync, writeFileSync,
-  openSync, closeSync, renameSync, readdirSync, statSync, unlinkSync,
+  openSync, closeSync, writeSync, renameSync, readdirSync, statSync, unlinkSync,
   constants as fsConstants,
 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -164,51 +164,204 @@ async function dlQuery(creds: Creds, sql: string): Promise<unknown[]> {
 // Pi avoids importing EmbedClient (which is bundled into other agents but
 // here would break the "raw .ts, zero deps" promise of pi extensions).
 // Instead we open a Unix socket directly to the daemon at the same well-known
-// path EmbedClient uses. If the socket isn't there yet, we spawn the
-// canonical daemon at ~/.hivemind/embed-deps/embed-daemon.js (deposited by
-// `hivemind embeddings install`) and wait for it to listen, mirroring the
-// auto-spawn-on-miss logic in src/embeddings/client.ts. Subsequent agents
-// (codex, CC, cursor, hermes, …) connect to the SAME daemon — pi pays the
-// cold-start cost only when it's the first user on the box.
+// path EmbedClient uses. If the socket isn't there yet AND the canonical
+// daemon binary exists at ~/.hivemind/embed-deps/embed-daemon.js (deposited
+// by `hivemind embeddings install`), we spawn it under an O_EXCL pidfile
+// lock and wait for it to listen. Subsequent agents (codex, CC, cursor,
+// hermes, …) connect to the SAME daemon — pi pays the cold-start cost only
+// when it's the first user on the box. This logic matches the source-tree
+// helper at src/embeddings/standalone-embed-client.ts (kept in lockstep:
+// the unit tests there cover the 11 edge cases mirrored here).
 //
 // Graceful fallback: any failure → return null → caller writes NULL into
-// message_embedding. Embedding is never on the critical path.
+// message_embedding. Embedding is NEVER on the critical path; pi must keep
+// working when the daemon is unreachable.
 
 const EMBED_DAEMON_ENTRY = join(homedir(), ".hivemind", "embed-deps", "embed-daemon.js");
-const EMBED_SOCKET_PATH = (() => {
-  const uid = typeof process.getuid === "function" ? String(process.getuid()) : (process.env.USER ?? "default");
-  return `/tmp/hivemind-embed-${uid}.sock`;
-})();
+// `process.env.USER` removed as a fallback: even though pi doesn't go
+// through ClawHub static-scan, we keep the source in lockstep with
+// src/embeddings/standalone-embed-client.ts (which DOES) so the two
+// implementations stay byte-identical. On Linux/macOS `process.getuid`
+// is always present; "default" is a fine sentinel elsewhere.
+const EMBED_UID = typeof process.getuid === "function" ? String(process.getuid()) : "default";
+const EMBED_SOCKET_PATH = `/tmp/hivemind-embed-${EMBED_UID}.sock`;
+const EMBED_PID_PATH = `/tmp/hivemind-embed-${EMBED_UID}.pid`;
+
+function isPidAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+// Three-state read: "empty" means the file exists but hasn't been
+// written yet — another caller is mid-spawn between openSync(wx) and
+// writeSync(pid). Treating that as stale lets two racing callers each
+// spawn a daemon, the second crashing on bind(). Mirrors
+// src/embeddings/standalone-embed-client.ts:readPidFile.
+function readPidFileInline(path: string): number | "empty" | null {
+  let raw: string;
+  try { raw = readFileSync(path, "utf-8").trim(); } catch { return null; }
+  if (raw === "") return "empty";
+  const pid = Number(raw);
+  if (!pid || Number.isNaN(pid)) return null;
+  return pid;
+}
 
-function tryEmbedOverSocket(text: string, kind: "document" | "query"): Promise<number[] | null> {
+function connectDaemonOnce(timeoutMs: number): Promise<ReturnType<typeof connect> | null> {
   return new Promise((resolve) => {
-    let resolved = false;
-    const settle = (v: number[] | null) => { if (!resolved) { resolved = true; resolve(v); } };
     const sock = connect(EMBED_SOCKET_PATH);
-    let buf = "";
-    const timer = setTimeout(() => { sock.destroy(); settle(null); }, 5000);
-    sock.on("connect", () => {
-      // Protocol shape comes from src/embeddings/protocol.ts: {op, id, kind, text}.
-      // id is a string ("1"), not a number, and the verb field is "op" not "type".
-      sock.write(JSON.stringify({ op: "embed", id: "1", kind, text }) + "\n");
+    const to = setTimeout(() => { try { sock.destroy(); } catch { /* */ } resolve(null); }, timeoutMs);
+    sock.once("connect", () => { clearTimeout(to); resolve(sock); });
+    sock.once("error", () => { clearTimeout(to); resolve(null); });
+  });
+}
+
+/**
+ * Spawn the canonical daemon under an O_EXCL pidfile lock. Returns true
+ * if THIS pi turn owns the spawn. Mirrors the helper in
+ * src/embeddings/standalone-embed-client.ts:
+ *   - live pidfile owner (case 6/7) → don't SIGTERM (PID-reuse risk from PR #168), let caller wait
+ *   - dead/garbage pidfile (case 5) → cleanup + spawn
+ *   - spawn() throws (case 8) → roll pidfile back so the next turn can retry
+ */
+function trySpawnDaemonInline(): boolean {
+  let fd: number;
+  try {
+    fd = openSync(EMBED_PID_PATH, "wx", 0o600);
+    // Write the placeholder PID through the open fd. The previous version
+    // used writeFileSync(path, ...) which races with concurrent unlink +
+    // re-open elsewhere — it could overwrite another caller's pidfile
+    // entirely. writeSync(fd, ...) writes to OUR fd only.
+    writeSync(fd, String(process.pid));
+  } catch {
+    const existing = readPidFileInline(EMBED_PID_PATH);
+    // Empty file: another caller won openSync(wx) but hasn't written its
+    // PID yet. We MUST NOT unlink + respawn — that lets us race past
+    // the legitimate writer and spawn a duplicate daemon. Wait instead.
+    if (existing === "empty") return false;
+    if (existing !== null && isPidAlive(existing)) {
+      // Live owner: another agent / pi turn is bringing the daemon up. Wait.
+      return false;
+    }
+    try { unlinkSync(EMBED_PID_PATH); } catch { /* */ }
+    try {
+      fd = openSync(EMBED_PID_PATH, "wx", 0o600);
+      writeSync(fd, String(process.pid));
+    } catch {
+      return false; // sub-ms race: another caller claimed it between our unlink and reopen
+    }
+  }
+  try {
+    // No explicit `env: process.env` — it's the spawn default, and a
+    // literal `process.env` reference in source kept in lockstep with
+    // src/embeddings/standalone-embed-client.ts (which DOES go through
+    // ClawHub static-scan from the openclaw bundle).
+    const child = spawn(process.execPath, [EMBED_DAEMON_ENTRY], {
+      detached: true,
+      stdio: "ignore",
     });
+    child.unref();
+    logHm(`embed: spawned daemon pid=${child.pid}`);
+    return true;
+  } catch (e: any) {
+    logHm(`embed: spawn failed: ${e?.message ?? e}`);
+    try { unlinkSync(EMBED_PID_PATH); } catch { /* */ }
+    return false;
+  } finally {
+    try { closeSync(fd); } catch { /* */ }
+  }
+}
+
+// After a spawnWaitMs timeout with daemon never opening socket, the
+// pidfile still holds OUR placeholder PID. Every subsequent pi turn
+// would see "live owner" (we're still running) and wait forever instead
+// of retrying the spawn. Clean up the placeholder, but only if it's
+// still ours — the daemon may have already overwritten it.
+//
+// Also clears an empty pidfile: if a prior pi turn was SIGKILL'd
+// between openSync(wx) and writeSync(pid), the empty file would persist
+// and every later turn would wait forever. By the time we hit this
+// cleanup we've waited 5s — orders of magnitude longer than the
+// legitimate openSync→writeSync gap.
+function maybeCleanupOwnPlaceholderInline(): void {
+  const existing = readPidFileInline(EMBED_PID_PATH);
+  if (existing === process.pid || existing === "empty") {
+    try { unlinkSync(EMBED_PID_PATH); } catch { /* already gone */ }
+  }
+}
+
+async function sendEmbedRequest(sock: ReturnType<typeof connect>, text: string, kind: "document" | "query", timeoutMs: number): Promise<number[] | null> {
+  return new Promise((resolve) => {
+    let resolved = false;
+    const settle = (v: number[] | null) => { if (!resolved) { resolved = true; resolve(v); try { sock.destroy(); } catch { /* */ } } };
+    let buf = "";
+    const timer = setTimeout(() => settle(null), timeoutMs);
     sock.on("data", (chunk: Buffer) => {
       buf += chunk.toString("utf-8");
       const nl = buf.indexOf("\n");
-      if (nl !== -1) {
-        clearTimeout(timer);
-        try {
-          const resp = JSON.parse(buf.slice(0, nl));
-          settle(Array.isArray(resp.embedding) ? resp.embedding : null);
-        } catch { settle(null); }
-        sock.destroy();
-      }
+      if (nl === -1) return;
+      clearTimeout(timer);
+      try {
+        const resp = JSON.parse(buf.slice(0, nl));
+        // Daemon may return `{ error: "unknown op" }` from an older protocol — graceful NULL.
+        if (!Array.isArray(resp.embedding)) return settle(null);
+        // JSON-over-socket is untrusted at runtime. Reject any non-finite
+        // element (string, null, NaN, Infinity, object). Without this, a
+        // misbehaving daemon could ship bad values that flow into the
+        // ARRAY[...]::FLOAT4[] SQL literal.
+        for (const v of resp.embedding) {
+          if (typeof v !== "number" || !Number.isFinite(v)) return settle(null);
+        }
+        settle(resp.embedding);
+      } catch { settle(null); }
     });
     sock.on("error", () => { clearTimeout(timer); settle(null); });
     sock.on("close", () => { clearTimeout(timer); settle(null); });
+    // Protocol shape comes from src/embeddings/protocol.ts: { op, id, kind, text }.
+    // id is a string ("1"), not a number, and the verb field is "op" not "type".
+    sock.write(JSON.stringify({ op: "embed", id: "1", kind, text }) + "\n");
   });
 }
 
+/**
+ * Full spawn-on-miss embedding flow. Returns null on any failure; never
+ * throws. 11 edge cases mirror the unit tests in
+ * tests/shared/standalone-embed-client.test.ts.
+ */
+async function tryEmbedOverSocket(text: string, kind: "document" | "query"): Promise<number[] | null> {
+  // Case 3 — happy path: socket alive, daemon ready.
+  let sock = await connectDaemonOnce(1000);
+  if (!sock) {
+    // Case 1 — binary missing: never spawn.
+    if (!existsSync(EMBED_DAEMON_ENTRY)) {
+      logHm(`embed: no daemon at ${EMBED_DAEMON_ENTRY} — run 'hivemind embeddings install'`);
+      return null;
+    }
+    // Cases 2 / 4 / 5 / 7 / 8 — trySpawn handles them; loser waits.
+    trySpawnDaemonInline();
+    // Case 9 — poll for socket up to 5s.
+    const deadline = Date.now() + 5000;
+    let delay = 30;
+    while (Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, delay));
+      delay = Math.min(delay * 1.5, 300);
+      if (!existsSync(EMBED_SOCKET_PATH)) continue;
+      sock = await connectDaemonOnce(1000);
+      if (sock) break;
+    }
+    if (!sock) {
+      // Clean up our placeholder PID so the next pi turn can retry the
+      // spawn instead of waiting on us forever.
+      maybeCleanupOwnPlaceholderInline();
+      logHm(`embed: daemon never opened socket within 5s`);
+      return null;
+    }
+  }
+  // Cases 10 / 11 — request timeout / daemon error → null.
+  const v = await sendEmbedRequest(sock, text, kind, 5000);
+  if (v === null) logHm(`embed: daemon returned null (timeout or error)`);
+  return v;
+}
+
 // ---------- summary state + wiki-worker spawn ---------------------------------
 //
 // Mirror of src/hooks/summary-state.ts (same dir, same JSON shape, shared
@@ -569,39 +722,12 @@ async function embed(text: string): Promise<number[] | null> {
     logHm(`embed: skipped (empty text)`);
     return null;
   }
-  // 1) socket already up (another agent or us in a previous turn) → fast path
-  let v = await tryEmbedOverSocket(text, "document");
-  if (v !== null) {
-    logHm(`embed: ok via existing socket (dims=${v.length})`);
-    return v;
-  }
-  // 2) no daemon binary deposited → fallback NULL
-  if (!existsSync(EMBED_DAEMON_ENTRY)) {
-    logHm(`embed: no daemon at ${EMBED_DAEMON_ENTRY} — run 'hivemind embeddings install'`);
-    return null;
-  }
-  // 3) spawn the canonical daemon detached; daemon's own pidfile lock guards
-  //    against double-spawn if multiple pi turns race.
-  logHm(`embed: spawning daemon at ${EMBED_DAEMON_ENTRY}`);
-  try {
-    spawn(process.execPath, [EMBED_DAEMON_ENTRY], { detached: true, stdio: "ignore" }).unref();
-  } catch (e: any) {
-    logHm(`embed: spawn failed: ${e?.message ?? e}`);
-    return null;
-  }
-  // 4) poll for the socket up to ~5s, then retry the embed once
-  for (let i = 0; i < 25; i++) {
-    await new Promise(r => setTimeout(r, 200));
-    if (existsSync(EMBED_SOCKET_PATH)) {
-      v = await tryEmbedOverSocket(text, "document");
-      if (v !== null) {
-        logHm(`embed: ok after spawn (dims=${v.length}, polls=${i + 1})`);
-        return v;
-      }
-    }
-  }
-  logHm(`embed: timed out after spawn (5s)`);
-  return null;
+  // Single round-trip: tryEmbedOverSocket spawns the daemon on miss
+  // (O_EXCL race-safe, mirrors src/embeddings/standalone-embed-client.ts)
+  // and embeds in one call. Returns null on any failure.
+  const v = await tryEmbedOverSocket(text, "document");
+  if (v !== null) logHm(`embed: ok (dims=${v.length})`);
+  return v;
 }
 
 function embedSqlLiteral(emb: number[] | null): string {