@memtensor/memos-local-openclaw-plugin 1.0.5 → 1.0.6-beta.1

package/index.ts

@@ -9,6 +9,7 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { Type } from "@sinclair/typebox";
 import * as fs from "fs";
 import * as path from "path";
+import { createRequire } from "node:module";
 import { fileURLToPath } from "url";
 import { buildContext } from "./src/config";
 import type { HostModelsConfig } from "./src/openclaw-api";
@@ -83,25 +84,56 @@ const memosLocalPlugin = {
   configSchema: pluginConfigSchema,
 
   register(api: OpenClawPluginApi) {
-    // ─── Ensure better-sqlite3 native module is available ───
-    const pluginDir = path.dirname(fileURLToPath(import.meta.url));
+    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+    const localRequire = createRequire(import.meta.url);
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+    function detectPluginDir(startDir: string): string {
+      let cur = startDir;
+      for (let i = 0; i < 6; i++) {
+        const pkg = path.join(cur, "package.json");
+        if (fs.existsSync(pkg)) return cur;
+        const parent = path.dirname(cur);
+        if (parent === cur) break;
+        cur = parent;
+      }
+      return startDir;
+    }
+
+    const pluginDir = detectPluginDir(moduleDir);
 
     function normalizeFsPath(p: string): string {
-      return path.resolve(p).replace(/\\/g, "/").toLowerCase();
+      return path.resolve(p).replace(/^\\\\\?\\/, "").toLowerCase();
+    }
+
+    function isPathInside(baseDir: string, targetPath: string): boolean {
+      const baseNorm = normalizeFsPath(baseDir);
+      const targetNorm = normalizeFsPath(targetPath);
+      const rel = path.relative(baseNorm, targetNorm);
+      return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    }
+
+    function runNpm(args: string[]) {
+      const { spawnSync } = localRequire("child_process") as typeof import("node:child_process");
+      return spawnSync(npmCmd, args, {
+        cwd: pluginDir,
+        stdio: "pipe",
+        shell: false,
+        timeout: 120_000,
+      });
     }
 
     let sqliteReady = false;
 
     function trySqliteLoad(): boolean {
       try {
-        const resolved = require.resolve("better-sqlite3", { paths: [pluginDir] });
-        const resolvedNorm = normalizeFsPath(resolved);
-        const pluginNorm = normalizeFsPath(pluginDir);
-        if (!resolvedNorm.startsWith(pluginNorm + "/") && resolvedNorm !== pluginNorm) {
+        const resolved = localRequire.resolve("better-sqlite3", { paths: [pluginDir] });
+        const resolvedReal = fs.existsSync(resolved) ? fs.realpathSync.native(resolved) : resolved;
+        if (!isPathInside(pluginDir, resolvedReal)) {
           api.logger.warn(`memos-local: better-sqlite3 resolved outside plugin dir: ${resolved}`);
           return false;
         }
-        require(resolved);
+        localRequire(resolvedReal);
         return true;
       } catch {
         return false;
@@ -114,13 +146,7 @@ const memosLocalPlugin = {
       api.logger.warn(`memos-local: better-sqlite3 not found in ${pluginDir}, attempting auto-rebuild ...`);
 
       try {
-        const { spawnSync } = require("child_process");
-        const rebuildResult = spawnSync("npm", ["rebuild", "better-sqlite3"], {
-          cwd: pluginDir,
-          stdio: "pipe",
-          shell: true,
-          timeout: 120_000,
-        });
+        const rebuildResult = runNpm(["rebuild", "better-sqlite3"]);
 
         const stdout = rebuildResult.stdout?.toString() || "";
         const stderr = rebuildResult.stderr?.toString() || "";
@@ -128,9 +154,9 @@ const memosLocalPlugin = {
         if (stderr) api.logger.warn(`memos-local: rebuild stderr: ${stderr.slice(0, 500)}`);
 
         if (rebuildResult.status === 0) {
-          Object.keys(require.cache)
+          Object.keys(localRequire.cache)
             .filter(k => k.includes("better-sqlite3") || k.includes("better_sqlite3"))
-            .forEach(k => delete require.cache[k]);
+            .forEach(k => delete localRequire.cache[k]);
           sqliteReady = trySqliteLoad();
           if (sqliteReady) {
             api.logger.info("memos-local: better-sqlite3 auto-rebuild succeeded!");
@@ -222,7 +248,7 @@ const memosLocalPlugin = {
 
     let pluginVersion = "0.0.0";
     try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs.readFileSync(path.join(pluginDir, "package.json"), "utf-8"));
       pluginVersion = pkg.version ?? pluginVersion;
     } catch {}
     const telemetry = new Telemetry(ctx.config.telemetry ?? {}, stateDir, pluginVersion, ctx.log, pluginDir);
@@ -406,7 +432,8 @@ const memosLocalPlugin = {
           updatedAt: now,
         });
       } else if (ctx.config.sharing?.enabled && hubClient.userId) {
-        store.upsertTeamSharedChunk(chunk.id, { hubMemoryId: memoryId, visibility, groupId });
+        const conn = store.getClientHubConnection();
+        store.upsertTeamSharedChunk(chunk.id, { hubMemoryId: memoryId, visibility, groupId, hubInstanceId: conn?.hubInstanceId ?? "" });
       }
 
       return { memoryId, visibility, groupId };
@@ -448,7 +475,7 @@ const memosLocalPlugin = {
           hubAddress: Type.Optional(Type.String({ description: "Optional Hub address override for group/all search." })),
           userToken: Type.Optional(Type.String({ description: "Optional Hub bearer token override for group/all search." })),
         }),
-        execute: trackTool("memory_search", async (_toolCallId: any, params: any) => {
+        execute: trackTool("memory_search", async (_toolCallId: any, params: any, context?: any) => {
           const {
             query,
             scope: rawScope,
@@ -474,8 +501,8 @@ const memosLocalPlugin = {
           }
           const searchLimit = typeof maxResults === "number" ? Math.max(1, Math.min(20, Math.round(maxResults))) : 10;
 
-          const agentId = currentAgentId;
-          const ownerFilter = [getCurrentOwner(), "public"];
+          const agentId = context?.agentId ?? currentAgentId;
+          const ownerFilter = [`agent:${agentId}`, "public"];
           const effectiveMaxResults = searchLimit;
           ctx.log.debug(`memory_search query="${query}" maxResults=${effectiveMaxResults} minScore=${minScore ?? 0.45} role=${role ?? "all"} owner=agent:${agentId}`);
           const result = await engine.search({ query, maxResults: effectiveMaxResults, minScore, role, ownerFilter });
@@ -713,14 +740,15 @@ const memosLocalPlugin = {
           chunkId: Type.String({ description: "The chunkId from a memory_search hit" }),
           window: Type.Optional(Type.Number({ description: "Context window ±N (default 2)" })),
         }),
-        execute: trackTool("memory_timeline", async (_toolCallId: any, params: any) => {
-          ctx.log.debug(`memory_timeline called (agent=${currentAgentId})`);
+        execute: trackTool("memory_timeline", async (_toolCallId: any, params: any, context?: any) => {
+          const agentId = context?.agentId ?? currentAgentId;
+          ctx.log.debug(`memory_timeline called (agent=${agentId})`);
           const { chunkId, window: win } = params as {
             chunkId: string;
             window?: number;
           };
 
-          const ownerFilter = [`agent:${currentAgentId}`, "public"];
+          const ownerFilter = [`agent:${agentId}`, "public"];
           const anchorChunk = store.getChunkForOwners(chunkId, ownerFilter);
           if (!anchorChunk) {
             return {
@@ -778,7 +806,8 @@ const memosLocalPlugin = {
           const { chunkId, maxChars } = params as { chunkId: string; maxChars?: number };
           const limit = Math.min(maxChars ?? DEFAULTS.getMaxCharsDefault, DEFAULTS.getMaxCharsMax);
 
-          const ownerFilter = [`agent:${currentAgentId}`, "public"];
+          const agentId = context?.agentId ?? currentAgentId;
+          const ownerFilter = [`agent:${agentId}`, "public"];
           const chunk = store.getChunkForOwners(chunkId, ownerFilter);
           if (!chunk) {
             return {
@@ -952,7 +981,8 @@ const memosLocalPlugin = {
             }),
           }) as any;
 
-          store.markTaskShared(task.id, hubTaskId, chunks.length, visibility, groupId);
+          const conn = store.getClientHubConnection();
+          store.markTaskShared(task.id, hubTaskId, chunks.length, visibility, groupId, conn?.hubInstanceId ?? "");
 
           return {
             content: [{ type: "text", text: `Shared task "${task.title}" with ${chunks.length} chunks to the hub.` }],
@@ -1781,7 +1811,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
 
     // ─── Auto-recall: inject relevant memories before agent starts ───
 
-    api.on("before_agent_start", async (event: { prompt?: string; messages?: unknown[] }, hookCtx?: { agentId?: string; sessionKey?: string }) => {
+    api.on("before_prompt_build", async (event: { prompt?: string; messages?: unknown[] }, hookCtx?: { agentId?: string; sessionKey?: string }) => {
       if (!allowPromptInjection) return {};
       if (!event.prompt || event.prompt.length < 3) return;
 
@@ -2245,6 +2275,10 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       const shared = store.listLocalSharedTasks();
       if (shared.length === 0) return;
 
+      // Only sync tasks that have a hub_task_id (actively shared to remote)
+      const conn = store.getClientHubConnection();
+      const currentHubInstanceId = conn?.hubInstanceId || "";
+
       let hubClient: { hubUrl: string; userToken: string; userId: string } | undefined;
       try {
         hubClient = await resolveHubClient(store, ctx);
@@ -2254,6 +2288,8 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
       const { v4: uuidv4 } = require("uuid");
 
       for (const entry of shared) {
+        if (!entry.hubTaskId) continue;
+        if (currentHubInstanceId && entry.hubInstanceId && entry.hubInstanceId !== currentHubInstanceId) continue;
         const task = store.getTask(entry.taskId);
         if (!task) continue;
         const chunks = store.getChunksByTask(entry.taskId);
@@ -2291,7 +2327,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
               })),
             }),
           });
-          store.markTaskShared(entry.taskId, entry.hubTaskId, chunks.length, entry.visibility, entry.groupId);
+          store.markTaskShared(entry.taskId, entry.hubTaskId, chunks.length, entry.visibility, entry.groupId, currentHubInstanceId);
         } catch (err) {
           ctx.log.warn(`incremental sync failed for task=${entry.taskId}: ${err}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "1.0.5",
+  "version": "1.0.6-beta.1",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",

package/scripts/postinstall.cjs

@@ -23,6 +23,11 @@ function phase(n, title) {
 }
 
 const pluginDir = path.resolve(__dirname, "..");
+const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+function normalizePathForMatch(p) {
+  return path.resolve(p).replace(/^\\\\\?\\/, "").replace(/\\/g, "/").toLowerCase();
+}
 
 console.log(`
 ${CYAN}${BOLD}┌──────────────────────────────────────────────────┐
@@ -42,7 +47,8 @@ log(`Node: ${process.version}  Platform: ${process.platform}-${process.arch}`);
  * ═══════════════════════════════════════════════════════════ */
 
 function cleanStaleArtifacts() {
-  const isExtensionsDir = pluginDir.includes(path.join(".openclaw", "extensions"));
+  const pluginDirNorm = normalizePathForMatch(pluginDir);
+  const isExtensionsDir = pluginDirNorm.includes("/.openclaw/extensions/");
   if (!isExtensionsDir) return;
 
   const pkgPath = path.join(pluginDir, "package.json");
@@ -133,10 +139,10 @@ function ensureDependencies() {
   log("Running: npm install --omit=dev ...");
 
   const startMs = Date.now();
-  const result = spawnSync("npm", ["install", "--omit=dev"], {
+  const result = spawnSync(npmCmd, ["install", "--omit=dev"], {
     cwd: pluginDir,
     stdio: "pipe",
-    shell: true,
+    shell: false,
     timeout: 120_000,
   });
   const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
@@ -223,8 +229,8 @@ function cleanupLegacy() {
             newEntry.source = oldSource
               .replace(/memos-lite-openclaw-plugin/g, "memos-local-openclaw-plugin")
               .replace(/memos-lite/g, "memos-local-openclaw-plugin")
-              .replace(/\/memos-local\//g, "/memos-local-openclaw-plugin/")
-              .replace(/\/memos-local$/g, "/memos-local-openclaw-plugin");
+              .replace(/[\\/]memos-local[\\/]/g, `${path.sep}memos-local-openclaw-plugin${path.sep}`)
+              .replace(/[\\/]memos-local$/g, `${path.sep}memos-local-openclaw-plugin`);
             if (newEntry.source !== oldSource) {
               log(`Updated source path: ${DIM}${oldSource}${RESET} → ${GREEN}${newEntry.source}${RESET}`);
               cfgChanged = true;
@@ -384,6 +390,16 @@ if (sqliteBindingsExist()) {
   warn("better-sqlite3 native bindings not found in plugin dir.");
   log(`Searched in: ${DIM}${sqliteModulePath}/build/${RESET}`);
   log("Running: npm rebuild better-sqlite3 (may take 30-60s)...");
+}
+
+const startMs = Date.now();
+
+const result = spawnSync(npmCmd, ["rebuild", "better-sqlite3"], {
+  cwd: pluginDir,
+  stdio: "pipe",
+  shell: false,
+  timeout: 180_000,
+});
 
   const startMs = Date.now();
   const result = spawnSync("npm", ["rebuild", "better-sqlite3"], {

package/src/capture/index.ts

@@ -4,6 +4,17 @@ const SKIP_ROLES: Set<Role> = new Set(["system"]);
 
 const SYSTEM_BOILERPLATE_RE = /^A new session was started via \/new or \/reset\b/;
 
+// Boot-check / memory-system injection patterns that should never be stored.
+const BOOT_CHECK_RE = /^(?:You are running a boot check|Read HEARTBEAT\.md if it exists|## Memory system — ACTION REQUIRED)/;
+
+/**
+ * Returns true for sentinel reply values that carry no user-facing content.
+ */
+function isSentinelReply(text: string): boolean {
+  const t = text.trim();
+  return t === "NO_REPLY" || t === "HEARTBEAT_OK" || t === "HEARTBEAT_CHECK";
+}
+
 const SELF_TOOLS = new Set([
   "memory_search",
   "memory_timeline",
@@ -61,6 +72,16 @@ export function captureMessages(
     if (SKIP_ROLES.has(role)) continue;
     if (!msg.content || msg.content.trim().length === 0) continue;
 
+    // Skip sentinel replies and boot-check prompts for ALL roles.
+    if (isSentinelReply(msg.content)) {
+      log.debug(`Skipping sentinel reply`);
+      continue;
+    }
+    if (BOOT_CHECK_RE.test(msg.content.trim())) {
+      log.debug(`Skipping boot-check injection: ${msg.content.slice(0, 60)}...`);
+      continue;
+    }
+
     if (role === "tool" && msg.toolName && SELF_TOOLS.has(msg.toolName)) {
       log.debug(`Skipping self-tool result: ${msg.toolName}`);
       continue;
@@ -232,6 +253,21 @@ function stripMemoryInjection(text: string): string {
     "",
   ).trim();
 
+  // ## Memory system — ACTION REQUIRED\n...
+  cleaned = cleaned.replace(
+    /## Memory system — ACTION REQUIRED[\s\S]*?(?=\n\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}|\n\[Subagent)/,
+    "",
+  ).trim();
+
+  // You are running a boot check. Follow BOOT.md instructions exactly.\n...
+  cleaned = cleaned.replace(
+    /^You are running a boot check[\s\S]*?(?=\n\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}|\n\[Subagent)/m,
+    "",
+  ).trim();
+
+  // Standalone NO_REPLY / HEARTBEAT_OK that leaked into user messages
+  cleaned = cleaned.replace(/^\s*(?:NO_REPLY|HEARTBEAT_OK|HEARTBEAT_CHECK)\s*$/gm, "").trim();
+
   // Old format: ## Retrieved memories from past conversations\n\nCRITICAL INSTRUCTION:...
   const recallIdx = cleaned.indexOf("## Retrieved memories from past conversations");
   if (recallIdx !== -1) {

package/src/client/connector.ts

@@ -49,6 +49,13 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
         }) as any;
         if (result.status === "active" && result.userToken) {
           log.info(`Pending user approved! Connecting with token. userId=${persisted.userId}`);
+          let approvedHubInstanceId = persisted.hubInstanceId || "";
+          if (!approvedHubInstanceId) {
+            try {
+              const info = await hubRequestJson(hubUrl, "", "/api/v1/hub/info", { method: "GET" }) as any;
+              approvedHubInstanceId = String(info?.hubInstanceId ?? "");
+            } catch { /* best-effort */ }
+          }
           store.setClientHubConnection({
             hubUrl,
             userId: persisted.userId,
@@ -58,6 +65,7 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
             connectedAt: Date.now(),
             identityKey: persisted.identityKey || "",
             lastKnownStatus: "active",
+            hubInstanceId: approvedHubInstanceId,
           });
           return store.getClientHubConnection()!;
         }
@@ -87,7 +95,10 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
   }
 
   const hubUrl = normalizeHubUrl(hubAddress);
-  const me = await hubRequestJson(hubUrl, userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+  const [me, info] = await Promise.all([
+    hubRequestJson(hubUrl, userToken, "/api/v1/hub/me", { method: "GET" }),
+    hubRequestJson(hubUrl, "", "/api/v1/hub/info", { method: "GET" }).catch(() => null),
+  ]) as [any, any];
   const persisted = store.getClientHubConnection();
   store.setClientHubConnection({
     hubUrl,
@@ -98,6 +109,7 @@ export async function connectToHub(store: SqliteStore, config: MemosLocalConfig,
     connectedAt: Date.now(),
     identityKey: persisted?.identityKey || String(me.identityKey ?? ""),
     lastKnownStatus: "active",
+    hubInstanceId: String(info?.hubInstanceId ?? persisted?.hubInstanceId ?? ""),
   });
   return store.getClientHubConnection()!;
 }
@@ -148,6 +160,7 @@ export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig)
             connectedAt: Date.now(),
             identityKey: conn.identityKey || "",
             lastKnownStatus: "active",
+            hubInstanceId: conn.hubInstanceId || "",
           });
           const me = await hubRequestJson(normalizeHubUrl(hubAddress), result.userToken, "/api/v1/hub/me", { method: "GET" }) as any;
           return {
@@ -293,6 +306,12 @@ export async function autoJoinHub(
   const existingIdentityKey = persisted?.identityKey || "";
 
   log.info(`Joining Hub at ${hubUrl} as "${username}"...`);
+  let hubInstanceId = "";
+  try {
+    const info = await hubRequestJson(hubUrl, "", "/api/v1/hub/info", { method: "GET" }) as any;
+    hubInstanceId = String(info?.hubInstanceId ?? "");
+  } catch { /* best-effort */ }
+
   const result = await hubRequestJson(hubUrl, "", "/api/v1/hub/join", {
     method: "POST",
     body: JSON.stringify({ teamToken, username, deviceName: hostname, clientIp, identityKey: existingIdentityKey }),
@@ -311,6 +330,7 @@ export async function autoJoinHub(
       connectedAt: Date.now(),
       identityKey: returnedIdentityKey,
       lastKnownStatus: "pending",
+      hubInstanceId,
     });
     throw new PendingApprovalError(result.userId);
   }
@@ -337,6 +357,7 @@ export async function autoJoinHub(
     connectedAt: Date.now(),
     identityKey: returnedIdentityKey,
     lastKnownStatus: "active",
+    hubInstanceId,
   });
   return store.getClientHubConnection()!;
 }

package/src/client/hub.ts

@@ -140,6 +140,7 @@ export async function hubUpdateUsername(
   newUsername: string,
 ): Promise<{ ok: boolean; username: string; userToken: string }> {
   const client = await resolveHubClient(store, ctx);
+  const persisted = store.getClientHubConnection();
   const result = await hubRequestJson(client.hubUrl, client.userToken, "/api/v1/hub/me/update-profile", {
     method: "POST",
     body: JSON.stringify({ username: newUsername }),
@@ -152,6 +153,9 @@ export async function hubUpdateUsername(
       userToken: result.userToken,
       role: client.role as "admin" | "member",
       connectedAt: Date.now(),
+      identityKey: persisted?.identityKey || "",
+      lastKnownStatus: "active",
+      hubInstanceId: persisted?.hubInstanceId || "",
     });
   }
   return result;

package/src/hub/server.ts

@@ -21,6 +21,7 @@ type HubAuthState = {
   authSecret: string;
   bootstrapAdminUserId?: string;
   bootstrapAdminToken?: string;
+  hubInstanceId?: string;
 };
 
 export class HubServer {
@@ -168,13 +169,23 @@ export class HubServer {
     return this.authState.authSecret;
   }
 
+  get hubInstanceId(): string {
+    return this.authState.hubInstanceId ?? "";
+  }
+
   private loadAuthState(): HubAuthState {
     try {
       const raw = fs.readFileSync(this.authStatePath, "utf8");
       const parsed = JSON.parse(raw) as HubAuthState;
-      if (parsed.authSecret) return parsed;
+      if (parsed.authSecret) {
+        if (!parsed.hubInstanceId) {
+          parsed.hubInstanceId = randomUUID();
+          fs.writeFileSync(this.authStatePath, JSON.stringify(parsed, null, 2), "utf8");
+        }
+        return parsed;
+      }
     } catch {}
-    const initial = { authSecret: randomBytes(32).toString("hex") } as HubAuthState;
+    const initial: HubAuthState = { authSecret: randomBytes(32).toString("hex"), hubInstanceId: randomUUID() };
     fs.mkdirSync(path.dirname(this.authStatePath), { recursive: true });
     fs.writeFileSync(this.authStatePath, JSON.stringify(initial, null, 2), "utf8");
     return initial;
@@ -215,19 +226,8 @@ export class HubServer {
     });
   }
 
-  private embedMemoryAsync(memoryId: string, summary: string, content: string): void {
-    const embedder = this.opts.embedder;
-    if (!embedder) return;
-    const text = summary || content.slice(0, 500);
-    embedder.embed([text]).then((vectors) => {
-      if (vectors[0]) {
-        this.opts.store.upsertHubMemoryEmbedding(memoryId, new Float32Array(vectors[0]));
-        this.opts.log.info(`hub: embedded shared memory ${memoryId}`);
-      }
-    }).catch((err) => {
-      this.opts.log.warn(`hub: embedding shared memory failed: ${err}`);
-    });
-  }
+  // Hub memory embeddings are now computed on-the-fly at search time (two-stage retrieval)
+  // rather than cached in hub_memory_embeddings table, so no embedMemoryAsync needed.
 
   private async handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const url = new URL(req.url || "/", `http://127.0.0.1:${this.port}`);
@@ -238,6 +238,7 @@ export class HubServer {
         teamName: this.teamName,
         version: "0.0.0",
         apiVersion: "v1",
+        hubInstanceId: this.hubInstanceId,
       });
     }
 
@@ -382,10 +383,13 @@ export class HubServer {
     }
 
     if (req.method === "POST" && routePath === "/api/v1/hub/leave") {
+      this.opts.store.deleteHubMemoriesByUser(auth.userId);
+      this.opts.store.deleteHubTasksByUser(auth.userId);
+      this.opts.store.deleteHubSkillsByUser(auth.userId);
       this.userManager.markUserLeft(auth.userId);
       this.knownOnlineUsers.delete(auth.userId);
       this.notifyAdmins("user_left", "user", auth.username, auth.userId);
-      this.opts.log.info(`Hub: user "${auth.username}" (${auth.userId}) left voluntarily, status set to "left"`);
+      this.opts.log.info(`Hub: user "${auth.username}" (${auth.userId}) left voluntarily, resources cleaned, status set to "left"`);
       return this.json(res, 200, { ok: true });
     }
 
@@ -611,9 +615,7 @@ export class HubServer {
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,
       });
-      if (this.opts.embedder) {
-        this.embedMemoryAsync(memoryId, String(m.summary || ""), String(m.content || ""));
-      }
+      // No embedding on share — hub memory vectors are computed on-the-fly at search time
       if (!existing) {
         this.notifyAdmins("resource_shared", "memory", String(m.summary || m.content?.slice(0, 60) || memoryId), auth.userId);
       }
@@ -660,24 +662,38 @@ export class HubServer {
       // Track which IDs are memories vs chunks
       const memoryIdSet = new Set(memFtsHits.map(({ hit }) => hit.id));
 
-      // Attempt vector search and RRF merge if embedder is available
+      // Two-stage retrieval: FTS candidates first, then embed + cosine rerank
       let mergedIds: string[];
       if (this.opts.embedder) {
         try {
           const [queryVec] = await this.opts.embedder.embed([query]);
           if (queryVec) {
             const allEmb = this.opts.store.getVisibleHubEmbeddings(auth.userId);
-            const memEmb = this.opts.store.getVisibleHubMemoryEmbeddings(auth.userId);
             const scored: Array<{ id: string; score: number }> = [];
-            const cosineSim = (vec: Float32Array) => {
+            const cosineSim = (a: Float32Array | number[], b: number[]) => {
               let dot = 0, nA = 0, nB = 0;
-              for (let i = 0; i < queryVec.length && i < vec.length; i++) {
-                dot += queryVec[i] * vec[i]; nA += queryVec[i] * queryVec[i]; nB += vec[i] * vec[i];
+              const len = Math.min(a.length, b.length);
+              for (let i = 0; i < len; i++) {
+                dot += a[i] * b[i]; nA += a[i] * a[i]; nB += b[i] * b[i];
               }
               return nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
             };
-            for (const e of allEmb) scored.push({ id: e.chunkId, score: cosineSim(e.vector) });
-            for (const e of memEmb) { scored.push({ id: e.memoryId, score: cosineSim(e.vector) }); memoryIdSet.add(e.memoryId); }
+            for (const e of allEmb) scored.push({ id: e.chunkId, score: cosineSim(e.vector, queryVec) });
+
+            // Hub memories: embed FTS candidates on-the-fly instead of reading cached vectors
+            if (memFtsHits.length > 0) {
+              const memTexts = memFtsHits.map(({ hit }) => (hit.summary || hit.content || "").slice(0, 500));
+              try {
+                const memVecs = await this.opts.embedder.embed(memTexts);
+                memFtsHits.forEach(({ hit }, i) => {
+                  if (memVecs[i]) {
+                    scored.push({ id: hit.id, score: cosineSim(new Float32Array(memVecs[i]), queryVec) });
+                    memoryIdSet.add(hit.id);
+                  }
+                });
+              } catch { /* best-effort */ }
+            }
+
             scored.sort((a, b) => b.score - a.score);
             const topScored = scored.slice(0, maxResults * 2);