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

package/scripts/postinstall.cjs

@@ -4,6 +4,7 @@
 const { spawnSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
+const { validateNativeBinding } = require("./native-binding.cjs");
 
 const RESET = "\x1b[0m";
 const GREEN = "\x1b[32m";
@@ -377,35 +378,31 @@ function findSqliteBinding() {
 
 function sqliteBindingsExist() {
   const found = findSqliteBinding();
-  if (found) {
-    log(`Native binding found: ${DIM}${found}${RESET}`);
-    return true;
+  if (!found) return false;
+  log(`Native binding found: ${DIM}${found}${RESET}`);
+  const status = validateNativeBinding(found);
+  if (status.ok) return true;
+  if (status.reason === "node-module-version") {
+    warn("Native binding exists but was compiled for a different Node.js version.");
+  } else {
+    warn("Native binding exists but failed to load.");
   }
+  warn(`${DIM}${status.message}${RESET}`);
   return false;
 }
 
 if (sqliteBindingsExist()) {
   ok("better-sqlite3 is ready.");
 } else {
-  warn("better-sqlite3 native bindings not found in plugin dir.");
+  warn("better-sqlite3 native bindings are missing or not loadable.");
   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"], {
+  const result = spawnSync(npmCmd, ["rebuild", "better-sqlite3"], {
     cwd: pluginDir,
     stdio: "pipe",
-    shell: true,
+    shell: false,
     timeout: 180_000,
   });
   const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);

package/src/client/connector.ts

@@ -229,22 +229,28 @@ export async function getHubStatus(store: SqliteStore, config: MemosLocalConfig)
             body: JSON.stringify({ teamToken, userId: conn.userId }),
           }) as any;
           if (regResult.status === "active" && regResult.userToken) {
-            store.setClientHubConnection({
+            const updatedConn = {
               ...conn,
               hubUrl: normalizeHubUrl(hubAddress),
               userToken: regResult.userToken,
               connectedAt: Date.now(),
               lastKnownStatus: "active",
-            });
+            };
+            store.setClientHubConnection(updatedConn);
             try {
               const me = await hubRequestJson(normalizeHubUrl(hubAddress), regResult.userToken, "/api/v1/hub/me", { method: "GET" }) as any;
+              const latestUsername = String(me.username ?? "");
+              const latestRole = String(me.role ?? "member") as UserRole;
+              if (latestUsername !== conn.username || latestRole !== conn.role) {
+                store.setClientHubConnection({ ...updatedConn, username: latestUsername, role: latestRole });
+              }
               return {
                 connected: true,
                 hubUrl: normalizeHubUrl(hubAddress),
                 user: {
                   id: String(me.id),
-                  username: String(me.username ?? ""),
-                  role: String(me.role ?? "member") as UserRole,
+                  username: latestUsername,
+                  role: latestRole,
                   status: String(me.status ?? "active"),
                   groups: Array.isArray(me.groups) ? me.groups : [],
                 },

package/src/hub/server.ts

@@ -124,6 +124,8 @@ export class HubServer {
     this.initOnlineTracking();
     this.offlineCheckTimer = setInterval(() => this.checkOfflineUsers(), HubServer.OFFLINE_CHECK_INTERVAL_MS);
 
+    this.backfillMemoryEmbeddings();
+
     return `http://127.0.0.1:${hubPort}`;
   }
 
@@ -226,8 +228,47 @@ export class HubServer {
     });
   }
 
-  // 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 backfillMemoryEmbeddings(): void {
+    if (!this.opts.embedder) return;
+    try {
+      const all = this.opts.store.listHubMemories({ limit: 500 });
+      const missing = all.filter(m => {
+        try { return !this.opts.store.getHubMemoryEmbedding(m.id); } catch { return true; }
+      });
+      if (missing.length === 0) return;
+      this.opts.log.info(`hub: backfilling embeddings for ${missing.length} hub memories`);
+      const texts = missing.map(m => (m.summary || m.content || "").slice(0, 500));
+      this.opts.embedder.embed(texts).then((vectors) => {
+        let count = 0;
+        for (let i = 0; i < vectors.length; i++) {
+          if (vectors[i]) {
+            this.opts.store.upsertHubMemoryEmbedding(missing[i].id, new Float32Array(vectors[i]));
+            count++;
+          }
+        }
+        this.opts.log.info(`hub: backfilled ${count}/${missing.length} memory embeddings`);
+      }).catch((err) => {
+        this.opts.log.warn(`hub: backfill memory embeddings failed: ${err}`);
+      });
+    } catch (err) {
+      this.opts.log.warn(`hub: backfill memory embeddings error: ${err}`);
+    }
+  }
+
+  private embedMemoryAsync(memoryId: string, summary: string, content: string): void {
+    const embedder = this.opts.embedder;
+    if (!embedder) return;
+    const text = (summary || content || "").slice(0, 500);
+    if (!text) return;
+    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}`);
+    });
+  }
 
   private async handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     const url = new URL(req.url || "/", `http://127.0.0.1:${this.port}`);
@@ -253,59 +294,64 @@ export class HubServer {
         || (req.headers["x-forwarded-for"] as string)?.split(",")[0]?.trim()
         || req.socket.remoteAddress || "";
       const identityKey = typeof body.identityKey === "string" ? body.identityKey.trim() : "";
+      const dryRun = body.dryRun === true;
 
-      let existingUser = identityKey
+      const identityMatch = identityKey
         ? this.userManager.findByIdentityKey(identityKey)
         : null;
-      if (!existingUser) {
-        const existingUsers = this.opts.store.listHubUsers();
-        existingUser = existingUsers.find(u => u.username === username && u.status !== "left" && u.status !== "removed") ?? null;
-      }
 
-      if (existingUser) {
-        try { this.opts.store.updateHubUserActivity(existingUser.id, joinIp); } catch { /* best-effort */ }
+      if (identityMatch) {
+        if (!dryRun) {
+          try { this.opts.store.updateHubUserActivity(identityMatch.id, joinIp); } catch { /* best-effort */ }
+        }
 
-        if (existingUser.status === "active") {
+        if (identityMatch.status === "active") {
+          if (dryRun) return this.json(res, 200, { status: "active", dryRun: true });
           const token = issueUserToken(
-            { userId: existingUser.id, username: existingUser.username, role: existingUser.role, status: "active" },
+            { userId: identityMatch.id, username: identityMatch.username, role: identityMatch.role, status: "active" },
             this.authSecret,
           );
-          this.userManager.approveUser(existingUser.id, token);
-          if (identityKey && !existingUser.identityKey) {
-            this.opts.store.upsertHubUser({ ...existingUser, identityKey });
-          }
-          return this.json(res, 200, { status: "active", userId: existingUser.id, userToken: token, identityKey: existingUser.identityKey || identityKey });
+          this.userManager.approveUser(identityMatch.id, token);
+          return this.json(res, 200, { status: "active", userId: identityMatch.id, userToken: token, identityKey: identityMatch.identityKey || identityKey });
         }
-        if (existingUser.status === "pending") {
-          this.notifyAdmins("user_join_request", "user", username, "", { dedup: true });
-          return this.json(res, 200, { status: "pending", userId: existingUser.id, identityKey: existingUser.identityKey || identityKey });
+        if (identityMatch.status === "pending") {
+          if (dryRun) return this.json(res, 200, { status: "pending", dryRun: true });
+          this.notifyAdmins("user_join_request", "user", identityMatch.username, "", { dedup: true });
+          return this.json(res, 200, { status: "pending", userId: identityMatch.id, identityKey: identityMatch.identityKey || identityKey });
         }
-        if (existingUser.status === "rejected") {
+        if (identityMatch.status === "rejected") {
+          if (dryRun) return this.json(res, 200, { status: "rejected", dryRun: true });
           if (body.reapply === true) {
-            this.userManager.resetToPending(existingUser.id);
-            this.notifyAdmins("user_join_request", "user", username, "");
-            this.opts.log.info(`Hub: rejected user "${username}" (${existingUser.id}) re-applied, reset to pending`);
-            return this.json(res, 200, { status: "pending", userId: existingUser.id, identityKey: existingUser.identityKey || identityKey });
+            this.userManager.resetToPending(identityMatch.id);
+            this.notifyAdmins("user_join_request", "user", identityMatch.username, "");
+            this.opts.log.info(`Hub: rejected user "${identityMatch.username}" (${identityMatch.id}) re-applied, reset to pending`);
+            return this.json(res, 200, { status: "pending", userId: identityMatch.id, identityKey: identityMatch.identityKey || identityKey });
           }
-          return this.json(res, 200, { status: "rejected", userId: existingUser.id });
-        }
-        if (existingUser.status === "removed") {
-          this.userManager.rejoinUser(existingUser.id);
-          this.notifyAdmins("user_join_request", "user", username, "", { dedup: true });
-          this.opts.log.info(`Hub: removed user "${username}" (${existingUser.id}) re-applied via rejoin, reset to pending`);
-          return this.json(res, 200, { status: "pending", userId: existingUser.id, identityKey: existingUser.identityKey || identityKey });
+          return this.json(res, 200, { status: "rejected", userId: identityMatch.id });
         }
-        if (existingUser.status === "left") {
-          this.userManager.rejoinUser(existingUser.id);
-          this.notifyAdmins("user_join_request", "user", username, "", { dedup: true });
-          this.opts.log.info(`Hub: left user "${username}" (${existingUser.id}) re-applied via rejoin, reset to pending`);
-          return this.json(res, 200, { status: "pending", userId: existingUser.id, identityKey: existingUser.identityKey || identityKey });
+        if (identityMatch.status === "removed" || identityMatch.status === "left") {
+          if (dryRun) return this.json(res, 200, { status: "can_rejoin", dryRun: true });
+          this.userManager.rejoinUser(identityMatch.id);
+          this.notifyAdmins("user_join_request", "user", identityMatch.username, "", { dedup: true });
+          this.opts.log.info(`Hub: ${identityMatch.status} user "${identityMatch.username}" (${identityMatch.id}) re-applied via rejoin, reset to pending`);
+          return this.json(res, 200, { status: "pending", userId: identityMatch.id, identityKey: identityMatch.identityKey || identityKey });
         }
-        if (existingUser.status === "blocked") {
-          return this.json(res, 200, { status: "blocked", userId: existingUser.id });
+        if (identityMatch.status === "blocked") {
+          return this.json(res, 200, { status: "blocked", userId: identityMatch.id });
         }
       }
 
+      const existingUsers = this.opts.store.listHubUsers();
+      const nameConflict = existingUsers.find(u => u.username === username);
+      if (nameConflict) {
+        this.opts.log.info(`Hub: join rejected — username "${username}" already taken by user ${nameConflict.id} (status=${nameConflict.status})`);
+        return this.json(res, 409, { error: "username_taken", message: `Username "${username}" is already in use. Please choose a different nickname.` });
+      }
+
+      if (dryRun) {
+        return this.json(res, 200, { status: "ok", dryRun: true });
+      }
+
       const generatedIdentityKey = identityKey || randomUUID();
       const user = this.userManager.createPendingUser({
         username,
@@ -534,6 +580,12 @@ export class HubServer {
         this.authState.bootstrapAdminToken = newToken;
         this.saveAuthState();
       }
+      try {
+        this.opts.store.insertHubNotification({
+          id: randomUUID(), userId, type: "username_renamed",
+          resource: "user", title: `Your nickname has been changed from "${user.username}" to "${newUsername}" by the admin.`,
+        });
+      } catch { /* best-effort */ }
       this.opts.log.info(`Hub: admin "${auth.userId}" renamed user "${userId}" to "${newUsername}"`);
       return this.json(res, 200, { ok: true, username: newUsername });
     }
@@ -615,7 +667,7 @@ export class HubServer {
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,
       });
-      // No embedding on share — hub memory vectors are computed on-the-fly at search time
+      this.embedMemoryAsync(memoryId, String(m.summary || ""), String(m.content || ""));
       if (!existing) {
         this.notifyAdmins("resource_shared", "memory", String(m.summary || m.content?.slice(0, 60) || memoryId), auth.userId);
       }
@@ -680,18 +732,10 @@ export class HubServer {
             };
             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 */ }
+            const memEmb = this.opts.store.getVisibleHubMemoryEmbeddings(auth.userId);
+            for (const e of memEmb) {
+              scored.push({ id: e.memoryId, score: cosineSim(e.vector, queryVec) });
+              memoryIdSet.add(e.memoryId);
             }
 
             scored.sort((a, b) => b.score - a.score);

package/src/ingest/providers/index.ts

@@ -1,20 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import type { SummarizerConfig, SummaryProvider, Logger, OpenClawAPI } from "../../types";
-import {
-  summarizeOpenAI,
-  summarizeTaskOpenAI,
-  generateTaskTitleOpenAI,
-  judgeNewTopicOpenAI,
-  filterRelevantOpenAI,
-  judgeDedupOpenAI,
-  parseFilterResult,
-  parseDedupResult,
-  TASK_SUMMARY_PROMPT,
-  TOPIC_JUDGE_PROMPT,
-  FILTER_RELEVANT_PROMPT,
-  DEDUP_JUDGE_PROMPT,
-} from "./openai";
+import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult } from "./openai";
 import type { FilterResult, DedupResult } from "./openai";
 export type { FilterResult, DedupResult } from "./openai";
 import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic, judgeNewTopicAnthropic, filterRelevantAnthropic, judgeDedupAnthropic } from "./anthropic";
@@ -342,6 +329,27 @@ export class Summarizer {
     return this.strongCfg;
   }
 
+  // ─── OpenClaw Prompts ───
+
+  static readonly OPENCLAW_TOPIC_JUDGE_PROMPT = `You are a conversation topic change detector.
+Given a CURRENT CONVERSATION SUMMARY and a NEW USER MESSAGE, decide: has the user started a COMPLETELY NEW topic that is unrelated to the current conversation?
+Reply with a single word: "NEW" if topic changed, "SAME" if it continues.`;
+
+  static readonly OPENCLAW_FILTER_RELEVANT_PROMPT = `You are a memory relevance judge.
+Given a QUERY and CANDIDATE memories, decide: does each candidate help answer the query?
+RULES:
+1. Include candidates whose content provides useful facts/context for the query.
+2. Exclude candidates that merely share a topic but contain no useful information.
+3. DEDUPLICATION: When multiple candidates convey the same or very similar information, keep ONLY the most complete one and exclude the rest.
+4. If none help, return {"relevant":[],"sufficient":false}.
+OUTPUT — JSON only: {"relevant":[1,3],"sufficient":true}`;
+
+  static readonly OPENCLAW_DEDUP_JUDGE_PROMPT = `You are a memory deduplication system.
+Given a NEW memory summary and EXISTING candidates, decide if the new memory duplicates any existing one.
+Reply with JSON: {"action":"MERGE","mergeTarget":2,"reason":"..."} or {"action":"NEW","reason":"..."}`;
+
+  static readonly OPENCLAW_TASK_SUMMARY_PROMPT = `Summarize the following task conversation into a structured report. Preserve key decisions, code, commands, and outcomes. Use the same language as the input.`;
+
   // ─── OpenClaw API Implementation ───
 
   private requireOpenClawAPI(): void {
@@ -373,7 +381,7 @@ export class Summarizer {
   private async summarizeTaskOpenClaw(text: string): Promise<string> {
     this.requireOpenClawAPI();
     const prompt = [
-      TASK_SUMMARY_PROMPT,
+      Summarizer.OPENCLAW_TASK_SUMMARY_PROMPT,
       ``,
       text,
     ].join("\n");
@@ -391,7 +399,7 @@ export class Summarizer {
   private async judgeNewTopicOpenClaw(currentContext: string, newMessage: string): Promise<boolean> {
     this.requireOpenClawAPI();
     const prompt = [
-      TOPIC_JUDGE_PROMPT,
+      Summarizer.OPENCLAW_TOPIC_JUDGE_PROMPT,
       ``,
       `CURRENT CONVERSATION SUMMARY:`,
       currentContext,
@@ -422,7 +430,7 @@ export class Summarizer {
       .join("\n");
 
     const prompt = [
-      FILTER_RELEVANT_PROMPT,
+      Summarizer.OPENCLAW_FILTER_RELEVANT_PROMPT,
       ``,
       `QUERY: ${query}`,
       ``,
@@ -450,7 +458,7 @@ export class Summarizer {
       .join("\n");
 
     const prompt = [
-      DEDUP_JUDGE_PROMPT,
+      Summarizer.OPENCLAW_DEDUP_JUDGE_PROMPT,
       ``,
       `NEW MEMORY:`,
       newSummary,

package/src/ingest/providers/openai.ts

@@ -16,7 +16,7 @@ Requirements:
 - Non-Chinese: 5-15 words (aim for 8-12)
 - Output title only`;
 
-export const TASK_SUMMARY_PROMPT = `You create a DETAILED task summary from a multi-turn conversation. This summary will be the ONLY record of this conversation, so it must preserve ALL important information.
+const TASK_SUMMARY_PROMPT = `You create a DETAILED task summary from a multi-turn conversation. This summary will be the ONLY record of this conversation, so it must preserve ALL important information.
 
 ## LANGUAGE RULE (HIGHEST PRIORITY)
 Detect the PRIMARY language of the user's messages. If most user messages are Chinese, ALL output (title, goal, steps, result, details) MUST be in Chinese. If English, output in English. NEVER mix. This rule overrides everything below.
@@ -178,7 +178,7 @@ export async function summarizeOpenAI(
   return json.choices[0]?.message?.content?.trim() ?? "";
 }
 
-export const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given the CURRENT task context and a NEW user message, decide if the new message belongs to the SAME task or starts a NEW one.
+const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given the CURRENT task context and a NEW user message, decide if the new message belongs to the SAME task or starts a NEW one.
 
 Answer ONLY "NEW" or "SAME".
 
@@ -246,7 +246,7 @@ export async function judgeNewTopicOpenAI(
   return answer.startsWith("NEW");
 }
 
-export const FILTER_RELEVANT_PROMPT = `You are a memory relevance judge.
+const FILTER_RELEVANT_PROMPT = `You are a memory relevance judge.
 
 Given a QUERY and CANDIDATE memories, decide: does each candidate's content contain information that would HELP ANSWER the query?
 
@@ -258,10 +258,11 @@ RULES:
 1. A candidate is relevant if its content provides facts, context, or data that directly supports answering the query.
 2. A candidate that merely shares the same broad topic/domain but contains NO useful information for answering is NOT relevant.
 3. If NO candidate can help answer the query, return {"relevant":[],"sufficient":false} — do NOT force-pick the "least irrelevant" one.
+4. DEDUPLICATION: When multiple candidates convey the same or very similar information, keep ONLY the most complete/detailed one and exclude the rest. Do NOT return near-duplicate snippets.
 
 OUTPUT — JSON only:
 {"relevant":[1,3],"sufficient":true}
-- "relevant": candidate numbers whose content helps answer the query. [] if none can help.
+- "relevant": candidate numbers whose content helps answer the query. [] if none can help. Duplicates removed — only unique information.
 - "sufficient": true only if the selected memories fully answer the query.`;
 
 export interface FilterResult {

package/src/recall/engine.ts

@@ -62,10 +62,20 @@ export class RecallEngine {
 
     // Step 1b: Pattern search (LIKE-based) as fallback for short terms that
     // trigram FTS cannot match (trigram requires >= 3 chars).
-    const shortTerms = query
-      .replace(/[."""(){}[\]*:^~!@#$%&\\/<>,;'`?？。，！、：""''（）【】《》]/g, " ")
-      .split(/\s+/)
-      .filter((t) => t.length === 2);
+    // For CJK text without spaces, extract bigrams (2-char sliding windows)
+    // so that queries like "唐波是谁" produce ["唐波", "波是", "是谁"].
+    const cleaned = query.replace(/[."""(){}[\]*:^~!@#$%&\\/<>,;'`?？。，！、：""''（）【】《》]/g, " ");
+    const spaceSplit = cleaned.split(/\s+/).filter((t) => t.length === 2);
+    const cjkBigrams: string[] = [];
+    const cjkRuns = cleaned.match(/[\u4e00-\u9fff\u3400-\u4dbf\uF900-\uFAFF]{2,}/g);
+    if (cjkRuns) {
+      for (const run of cjkRuns) {
+        for (let i = 0; i <= run.length - 2; i++) {
+          cjkBigrams.push(run.slice(i, i + 2));
+        }
+      }
+    }
+    const shortTerms = [...new Set([...spaceSplit, ...cjkBigrams])];
     const patternHits = shortTerms.length > 0
       ? this.store.patternSearch(shortTerms, { limit: candidatePool })
       : [];
@@ -74,58 +84,41 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
-    // Step 1c: Hub memories — two-stage retrieval (no cached embeddings).
-    // Stage 1: FTS + pattern to get candidates.
-    // Stage 2: embed candidates on-the-fly + cosine rerank.
+    // Step 1c: Hub memories — FTS + pattern + cached embeddings (same strategy as chunks/skills).
     let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
     let hubMemVecRanked: Array<{ id: string; score: number }> = [];
     let hubMemPatternRanked: Array<{ id: string; score: number }> = [];
     if (query && this.ctx.config.sharing?.enabled && this.ctx.config.sharing.role === "hub") {
-      // Stage 1: cheap text retrieval
-      const hubCandidateTexts = new Map<string, string>();
       try {
         const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
-        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => {
-          hubCandidateTexts.set(hit.id, (hit.summary || hit.content || "").slice(0, 500));
-          return { id: `hubmem:${hit.id}`, score: 1 / (i + 1) };
-        });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({ id: `hubmem:${hit.id}`, score: 1 / (i + 1) }));
       } catch { /* hub_memories table may not exist */ }
       if (shortTerms.length > 0) {
         try {
           const hubPatternHits = this.store.hubMemoryPatternSearch(shortTerms, { limit: candidatePool });
-          hubMemPatternRanked = hubPatternHits.map((h, i) => {
-            hubCandidateTexts.set(h.memoryId, (h.content || "").slice(0, 500));
-            return { id: `hubmem:${h.memoryId}`, score: 1 / (i + 1) };
-          });
+          hubMemPatternRanked = hubPatternHits.map((h, i) => ({ id: `hubmem:${h.memoryId}`, score: 1 / (i + 1) }));
         } catch { /* best-effort */ }
       }
 
-      // Stage 2: embed candidates on-the-fly and cosine rerank
-      if (hubCandidateTexts.size > 0) {
-        try {
-          const qv = await this.embedder.embedQuery(query).catch(() => null);
-          if (qv) {
-            const ids = [...hubCandidateTexts.keys()];
-            const texts = ids.map(id => hubCandidateTexts.get(id)!);
-            const vecs = await this.embedder.embed(texts);
-            const scored: Array<{ id: string; score: number }> = [];
-            for (let j = 0; j < ids.length; j++) {
-              if (!vecs[j]) continue;
-              const v = vecs[j];
-              let dot = 0, nA = 0, nB = 0;
-              for (let i = 0; i < qv.length && i < v.length; i++) {
-                dot += qv[i] * v[i]; nA += qv[i] * qv[i]; nB += v[i] * v[i];
-              }
-              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
-              if (sim > 0.3) {
-                scored.push({ id: `hubmem:${ids[j]}`, score: sim });
-              }
+      try {
+        const qv = await this.embedder.embedQuery(query).catch(() => null);
+        if (qv) {
+          const memEmbs = this.store.getVisibleHubMemoryEmbeddings("__hub__");
+          const scored: Array<{ id: string; score: number }> = [];
+          for (const e of memEmbs) {
+            let dot = 0, nA = 0, nB = 0;
+            const len = Math.min(qv.length, e.vector.length);
+            for (let i = 0; i < len; i++) {
+              dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
             }
-            scored.sort((a, b) => b.score - a.score);
-            hubMemVecRanked = scored.slice(0, candidatePool);
+            const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+            if (sim > 0.3) scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
           }
-        } catch { /* best-effort */ }
-      }
+          scored.sort((a, b) => b.score - a.score);
+          hubMemVecRanked = scored.slice(0, candidatePool);
+        }
+      } catch { /* best-effort */ }
+
       const hubTotal = hubMemFtsRanked.length + hubMemVecRanked.length + hubMemPatternRanked.length;
       if (hubTotal > 0) {
         this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}, pattern=${hubMemPatternRanked.length}`);

package/src/storage/sqlite.ts

@@ -1005,7 +1005,12 @@ export class SqliteStore {
       CREATE INDEX IF NOT EXISTS idx_hub_memories_visibility ON hub_memories(visibility);
       CREATE INDEX IF NOT EXISTS idx_hub_memories_group ON hub_memories(group_id);
 
-      -- hub_memory_embeddings removed: vectors are now computed on-the-fly at search time
+      CREATE TABLE IF NOT EXISTS hub_memory_embeddings (
+        memory_id   TEXT PRIMARY KEY REFERENCES hub_memories(id) ON DELETE CASCADE,
+        vector      BLOB NOT NULL,
+        dimensions  INTEGER NOT NULL,
+        updated_at  INTEGER NOT NULL
+      );
 
       CREATE VIRTUAL TABLE IF NOT EXISTS hub_memories_fts USING fts5(
         summary,
@@ -1252,6 +1257,13 @@ export class SqliteStore {
     } catch { return []; }
   }
 
+  listHubMemories(opts: { limit?: number } = {}): Array<{ id: string; summary?: string; content?: string }> {
+    const limit = opts.limit ?? 200;
+    try {
+      return this.db.prepare("SELECT id, summary, content FROM hub_memories ORDER BY created_at DESC LIMIT ?").all(limit) as Array<{ id: string; summary?: string; content?: string }>;
+    } catch { return []; }
+  }
+
   // ─── Vector Search ───
 
   getAllEmbeddings(ownerFilter?: string[]): Array<{ chunkId: string; vector: number[] }> {
@@ -2194,6 +2206,36 @@ export class SqliteStore {
     }));
   }
 
+  upsertHubMemoryEmbedding(memoryId: string, vector: Float32Array): void {
+    const buf = Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+    this.db.prepare(`
+      INSERT INTO hub_memory_embeddings (memory_id, vector, dimensions, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, dimensions = excluded.dimensions, updated_at = excluded.updated_at
+    `).run(memoryId, buf, vector.length, Date.now());
+  }
+
+  getHubMemoryEmbedding(memoryId: string): Float32Array | null {
+    const row = this.db.prepare('SELECT vector, dimensions FROM hub_memory_embeddings WHERE memory_id = ?').get(memoryId) as { vector: Buffer; dimensions: number } | undefined;
+    if (!row) return null;
+    return new Float32Array(row.vector.buffer, row.vector.byteOffset, row.dimensions);
+  }
+
+  getVisibleHubMemoryEmbeddings(userId: string): Array<{ memoryId: string; vector: Float32Array }> {
+    const rows = this.db.prepare(`
+      SELECT hme.memory_id, hme.vector, hme.dimensions
+      FROM hub_memory_embeddings hme
+      JOIN hub_memories hm ON hm.id = hme.memory_id
+      WHERE hm.visibility = 'public'
+        OR hm.source_user_id = ?
+        OR EXISTS (SELECT 1 FROM hub_group_members gm WHERE gm.group_id = hm.group_id AND gm.user_id = ?)
+    `).all(userId, userId) as Array<{ memory_id: string; vector: Buffer; dimensions: number }>;
+    return rows.map(r => ({
+      memoryId: r.memory_id,
+      vector: new Float32Array(r.vector.buffer, r.vector.byteOffset, r.dimensions),
+    }));
+  }
+
   searchHubChunks(query: string, options?: { userId?: string; maxResults?: number }): Array<{ hit: HubSearchRow; rank: number }> {
     const limit = options?.maxResults ?? 10;
     const userId = options?.userId ?? "";

package/src/update-check.ts

@@ -52,26 +52,21 @@ export async function computeUpdateCheck(
 
   if (onBeta) {
     channel = "beta";
-    // Beta users: only compare against beta tag; never suggest "updating" to stable via gt confusion.
     if (betaTag && semver.valid(betaTag) && semver.gt(betaTag, current)) {
       updateAvailable = true;
       targetVersion = betaTag;
-      installCommand = `openclaw plugins install ${packageName}@beta`;
     } else {
       targetVersion = betaTag && semver.valid(betaTag) ? betaTag : current;
-      if (betaTag && semver.valid(betaTag) && semver.eq(betaTag, current)) {
-        installCommand = `openclaw plugins install ${packageName}@beta`;
-      }
     }
+    installCommand = `openclaw plugins install ${packageName}@${targetVersion}`;
   } else {
-    // Stable users: compare against latest only.
     if (latestTag && semver.valid(latestTag) && semver.gt(latestTag, current)) {
       updateAvailable = true;
       targetVersion = latestTag;
-      installCommand = `openclaw plugins install ${packageName}`;
     } else {
       targetVersion = latestTag && semver.valid(latestTag) ? latestTag : current;
     }
+    installCommand = `openclaw plugins install ${packageName}@${targetVersion}`;
   }
 
   // Beta user + stable exists on latest: optional hint to switch to stable (not counted as "update").