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

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);
@@ -314,25 +340,11 @@ const memosLocalPlugin = {
           try {
             let outputText: string;
             const det = result?.details;
-            if (det && Array.isArray(det.candidates)) {
-              outputText = JSON.stringify({
-                candidates: det.candidates,
-                filtered: det.hits ?? det.filtered ?? [],
-              });
-            } else if (det && det.local && det.hub) {
-              const localHits = det.local?.hits ?? [];
-              const hubHits = (det.hub?.hits ?? []).map((h: any) => ({
-                score: h.score ?? 0,
-                role: h.source?.role ?? h.role ?? "assistant",
-                summary: h.summary ?? "",
-                original_excerpt: h.excerpt ?? h.summary ?? "",
-                origin: "hub-remote",
-                ownerName: h.ownerName ?? "",
-                groupName: h.groupName ?? "",
-              }));
+            if (det && (Array.isArray(det.candidates) || Array.isArray(det.filtered))) {
               outputText = JSON.stringify({
-                candidates: [...localHits, ...hubHits],
-                filtered: [...localHits, ...hubHits],
+                candidates: det.candidates ?? [],
+                hubCandidates: det.hubCandidates ?? [],
+                filtered: det.filtered ?? det.hits ?? [],
               });
             } else {
               outputText = result?.content?.[0]?.text ?? JSON.stringify(result ?? "");
@@ -406,7 +418,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 +461,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,14 +487,26 @@ 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 });
-          ctx.log.debug(`memory_search raw candidates: ${result.hits.length}`);
 
-          const rawCandidates = result.hits.map((h) => ({
+          // ── Phase 1: Local search ∥ Hub search (parallel) ──
+          const localSearchP = engine.search({ query, maxResults: effectiveMaxResults, minScore, role, ownerFilter });
+          const hubSearchP = searchScope !== "local"
+            ? hubSearchMemories(store, ctx, { query, maxResults: searchLimit, scope: searchScope as any, hubAddress, userToken })
+                .catch(() => ({ hits: [] as any[], meta: { totalCandidates: 0, searchedGroups: [] as string[], includedPublic: searchScope === "all" } }))
+            : Promise.resolve(null);
+
+          const [result, hubResult] = await Promise.all([localSearchP, hubSearchP]);
+          ctx.log.debug(`memory_search raw candidates: local=${result.hits.length}, hub=${hubResult?.hits?.length ?? 0}`);
+
+          // Split local results: pure-local vs hub-memory (Hub role's hub_memories mixed in by RecallEngine)
+          const localHits = result.hits.filter((h) => h.origin !== "hub-memory");
+          const hubLocalHits = result.hits.filter((h) => h.origin === "hub-memory");
+
+          const rawLocalCandidates = localHits.map((h) => ({
             chunkId: h.ref.chunkId,
             role: h.source.role,
             score: h.score,
@@ -490,208 +515,156 @@ const memosLocalPlugin = {
             origin: h.origin || "local",
           }));
 
-          if (result.hits.length === 0 && searchScope === "local") {
+          // Hub remote candidates (from HTTP call) + hub-memory candidates (from RecallEngine for Hub role)
+          const hubRemoteHits = hubResult?.hits ?? [];
+          const rawHubCandidates = [
+            ...hubLocalHits.map((h) => ({
+              score: h.score,
+              role: h.source.role,
+              summary: h.summary,
+              original_excerpt: (h.original_excerpt ?? "").slice(0, 200),
+              origin: "hub-memory" as const,
+              ownerName: "",
+              groupName: "",
+            })),
+            ...hubRemoteHits.map((h: any) => ({
+              score: h.score ?? 0,
+              role: h.source?.role ?? h.role ?? "assistant",
+              summary: h.summary ?? "",
+              original_excerpt: (h.excerpt ?? h.summary ?? "").slice(0, 200),
+              origin: "hub-remote" as const,
+              ownerName: h.ownerName ?? "",
+              groupName: h.groupName ?? "",
+            })),
+          ];
+
+          if (localHits.length === 0 && rawHubCandidates.length === 0) {
             return {
               content: [{ type: "text", text: result.meta.note ?? "No relevant memories found." }],
-              details: { candidates: [], meta: result.meta },
+              details: { candidates: rawLocalCandidates, hubCandidates: [], filtered: [], meta: result.meta },
             };
           }
 
-          let filteredHits = result.hits;
-          let sufficient = false;
-
-          const candidates = result.hits.map((h, i) => ({
-            index: i + 1,
-            role: h.source.role,
-            content: (h.original_excerpt ?? "").slice(0, 300),
-            time: h.source.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
-          }));
-
-          const filterResult = await summarizer.filterRelevant(query, candidates);
-          if (filterResult !== null) {
-            sufficient = filterResult.sufficient;
-            if (filterResult.relevant.length > 0) {
-              const indexSet = new Set(filterResult.relevant);
-              filteredHits = result.hits.filter((_, i) => indexSet.has(i + 1));
-              ctx.log.debug(`memory_search LLM filter: ${result.hits.length} → ${filteredHits.length} hits, sufficient=${sufficient}`);
-            } else if (searchScope === "local") {
-              return {
-                content: [{ type: "text", text: "No relevant memories found for this query." }],
-                details: { candidates: rawCandidates, filtered: [], meta: result.meta },
-              };
-            } else {
-              filteredHits = [];
-            }
-          }
-
-          const beforeDedup = filteredHits.length;
-          filteredHits = deduplicateHits(filteredHits);
-          ctx.log.debug(`memory_search dedup: ${beforeDedup} → ${filteredHits.length}`);
-
-          const localDetailsHits = filteredHits.map((h) => {
-            let effectiveTaskId = h.taskId;
-            if (effectiveTaskId) {
-              const t = store.getTask(effectiveTaskId);
-              if (t && t.status === "skipped") effectiveTaskId = null;
-            }
-            return {
-              ref: h.ref,
-              chunkId: h.ref.chunkId,
-              taskId: effectiveTaskId,
-              skillId: h.skillId,
+          // ── Phase 2: Merge all candidates → single LLM filter ──
+          const allHitsForFilter = [...localHits, ...hubLocalHits];
+          const hubRemoteForFilter = hubRemoteHits;
+          const mergedCandidates = [
+            ...allHitsForFilter.map((h, i) => ({
+              index: i + 1,
               role: h.source.role,
-              score: h.score,
-              summary: h.summary,
-              origin: h.origin || "local",
-            };
-          });
+              content: (h.original_excerpt ?? "").slice(0, 300),
+              time: h.source.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
+            })),
+            ...hubRemoteForFilter.map((h: any, i: number) => ({
+              index: allHitsForFilter.length + i + 1,
+              role: (h.source?.role || "assistant") as string,
+              content: (h.summary || h.excerpt || "").slice(0, 300),
+              time: h.source?.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
+            })),
+          ];
+
+          let filteredLocalHits = allHitsForFilter;
+          let filteredHubRemoteHits = hubRemoteForFilter;
+          let sufficient = false;
 
-          if (searchScope !== "local") {
-            const hub = await hubSearchMemories(store, ctx, { query, maxResults: searchLimit, scope: searchScope as any, hubAddress, userToken }).catch(() => ({ hits: [], meta: { totalCandidates: 0, searchedGroups: [], includedPublic: searchScope === "all" } }));
-
-            let filteredHubHits = hub.hits;
-            if (hub.hits.length > 0) {
-              const hubCandidates = hub.hits.map((h, i) => ({
-                index: filteredHits.length + i + 1,
-                role: (h.source?.role || "assistant") as string,
-                content: (h.summary || h.excerpt || "").slice(0, 300),
-                time: h.source?.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
-              }));
-              const localCandidatesForMerge = filteredHits.map((h, i) => ({
-                index: i + 1,
-                role: h.source.role,
-                content: (h.original_excerpt ?? "").slice(0, 300),
-                time: h.source.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
-              }));
-              const mergedCandidates = [...localCandidatesForMerge, ...hubCandidates];
-              const mergedFilter = await summarizer.filterRelevant(query, mergedCandidates);
-              if (mergedFilter !== null && mergedFilter.relevant.length > 0) {
-                const relevantSet = new Set(mergedFilter.relevant);
-                const hubStartIdx = filteredHits.length + 1;
-                filteredHits = filteredHits.filter((_, i) => relevantSet.has(i + 1));
-                filteredHubHits = hub.hits.filter((_, i) => relevantSet.has(hubStartIdx + i));
-                ctx.log.debug(`memory_search LLM filter (merged): local ${localCandidatesForMerge.length}→${filteredHits.length}, hub ${hub.hits.length}→${filteredHubHits.length}`);
+          if (mergedCandidates.length > 0) {
+            const filterResult = await summarizer.filterRelevant(query, mergedCandidates);
+            if (filterResult !== null) {
+              sufficient = filterResult.sufficient;
+              if (filterResult.relevant.length > 0) {
+                const relevantSet = new Set(filterResult.relevant);
+                const hubStartIdx = allHitsForFilter.length + 1;
+                filteredLocalHits = allHitsForFilter.filter((_, i) => relevantSet.has(i + 1));
+                filteredHubRemoteHits = hubRemoteForFilter.filter((_: any, i: number) => relevantSet.has(hubStartIdx + i));
+                ctx.log.debug(`memory_search LLM filter: merged ${mergedCandidates.length} → local ${filteredLocalHits.length}, hub ${filteredHubRemoteHits.length}`);
+              } else {
+                filteredLocalHits = [];
+                filteredHubRemoteHits = [];
               }
             }
-
-            const originLabel = (h: SearchHit) => {
-              if (h.origin === "hub-memory") return " [团队缓存]";
-              if (h.origin === "local-shared") return " [本机共享]";
-              return "";
-            };
-            const localText = filteredHits.length > 0
-              ? filteredHits.map((h, i) => {
-                  const excerpt = h.original_excerpt.length > 220 ? h.original_excerpt.slice(0, 217) + "..." : h.original_excerpt;
-                  return `${i + 1}. [${h.source.role}]${originLabel(h)} ${excerpt}`;
-                }).join("\n")
-              : "(none)";
-            const hubText = filteredHubHits.length > 0
-              ? filteredHubHits.map((h, i) => `${i + 1}. [${h.ownerName}] [团队] ${h.summary}${h.groupName ? ` (${h.groupName})` : ""}`).join("\n")
-              : "(none)";
-
-            const localDetailsFiltered = filteredHits.map((h) => {
-              let effectiveTaskId = h.taskId;
-              if (effectiveTaskId) {
-                const t = store.getTask(effectiveTaskId);
-                if (t && t.status === "skipped") effectiveTaskId = null;
-              }
-              return {
-                ref: h.ref,
-                chunkId: h.ref.chunkId,
-                taskId: effectiveTaskId,
-                skillId: h.skillId,
-                role: h.source.role,
-                score: h.score,
-                summary: h.summary,
-                origin: h.origin,
-              };
-            });
-
-            return {
-              content: [{
-                type: "text",
-                text: `Local results:\n${localText}\n\nHub results:\n${hubText}`,
-              }],
-              details: {
-                local: { hits: localDetailsFiltered, meta: result.meta },
-                hub: { ...hub, hits: filteredHubHits },
-              },
-            };
           }
 
-          if (filteredHits.length === 0) {
+          const beforeDedup = filteredLocalHits.length;
+          filteredLocalHits = deduplicateHits(filteredLocalHits);
+          ctx.log.debug(`memory_search dedup: ${beforeDedup} → ${filteredLocalHits.length}`);
+
+          if (filteredLocalHits.length === 0 && filteredHubRemoteHits.length === 0) {
             return {
               content: [{ type: "text", text: "No relevant memories found for this query." }],
-              details: { candidates: rawCandidates, filtered: [], meta: result.meta },
+              details: { candidates: rawLocalCandidates, hubCandidates: rawHubCandidates, filtered: [], meta: result.meta },
             };
           }
 
+          // ── Phase 3: Build response text ──
           const originTag = (o?: string) => {
             if (o === "local-shared") return " [本机共享]";
             if (o === "hub-memory") return " [团队缓存]";
             if (o === "hub-remote") return " [团队]";
             return "";
           };
-          const lines = filteredHits.map((h, i) => {
-            const excerpt = h.original_excerpt;
-            const parts = [`${i + 1}. [${h.source.role}]${originTag(h.origin)}`];
-            if (excerpt) parts.push(`   ${excerpt}`);
+
+          const localLines = filteredLocalHits.map((h, i) => {
+            const excerpt = h.original_excerpt.length > 220 ? h.original_excerpt.slice(0, 217) + "..." : h.original_excerpt;
+            const parts = [`${i + 1}. [${h.source.role}]${originTag(h.origin)} ${excerpt}`];
             parts.push(`   chunkId="${h.ref.chunkId}"`);
             if (h.taskId) {
               const task = store.getTask(h.taskId);
-              if (task && task.status !== "skipped") {
-                parts.push(`   task_id="${h.taskId}"`);
-              }
+              if (task && task.status !== "skipped") parts.push(`   task_id="${h.taskId}"`);
             }
             return parts.join("\n");
           });
 
+          const hubLines = filteredHubRemoteHits.map((h: any, i: number) =>
+            `${i + 1}. [${h.ownerName ?? "team"}] [团队] ${h.summary ?? ""}${h.groupName ? ` (${h.groupName})` : ""}`
+          );
+
           let tipsText = "";
           if (!sufficient) {
-            const hasTask = filteredHits.some((h) => {
+            const hasTask = filteredLocalHits.some((h) => {
               if (!h.taskId) return false;
               const t = store.getTask(h.taskId);
               return t && t.status !== "skipped";
             });
-
             const tips: string[] = [];
             if (hasTask) {
               tips.push("→ call task_summary(taskId) for full task context");
               tips.push("→ call skill_get(taskId=...) if the task has a proven experience guide");
             }
             tips.push("→ call memory_timeline(chunkId) to expand surrounding conversation");
-
-            if (tips.length > 0) {
-              tipsText = "\n\nThese memories may not be enough. You can fetch more context:\n" + tips.join("\n");
-            }
+            if (tips.length > 0) tipsText = "\n\nThese memories may not be enough. You can fetch more context:\n" + tips.join("\n");
           }
 
+          const localText = localLines.length > 0 ? localLines.join("\n\n") : "(none)";
+          const hubText = hubLines.length > 0 ? hubLines.join("\n") : "(none)";
+          const totalFiltered = filteredLocalHits.length + filteredHubRemoteHits.length;
+          const responseText = filteredHubRemoteHits.length > 0
+            ? `Found ${totalFiltered} relevant memories:\n\nLocal results:\n${localText}\n\nHub results:\n${hubText}${tipsText}`
+            : `Found ${totalFiltered} relevant memories:\n\n${localText}${tipsText}`;
+
+          const filteredDetails = [
+            ...filteredLocalHits.map((h) => {
+              let effectiveTaskId = h.taskId;
+              if (effectiveTaskId) { const t = store.getTask(effectiveTaskId); if (t && t.status === "skipped") effectiveTaskId = null; }
+              return {
+                chunkId: h.ref.chunkId, taskId: effectiveTaskId, skillId: h.skillId,
+                role: h.source.role, score: h.score, summary: h.summary,
+                original_excerpt: (h.original_excerpt ?? "").slice(0, 200), origin: h.origin || "local",
+              };
+            }),
+            ...filteredHubRemoteHits.map((h: any) => ({
+              chunkId: "", taskId: null, skillId: null,
+              role: h.source?.role ?? h.role ?? "assistant", score: h.score ?? 0,
+              summary: h.summary ?? "", original_excerpt: (h.excerpt ?? h.summary ?? "").slice(0, 200),
+              origin: "hub-remote", ownerName: h.ownerName ?? "", groupName: h.groupName ?? "",
+            })),
+          ];
+
           return {
-            content: [
-              {
-                type: "text",
-                text: `Found ${filteredHits.length} relevant memories:\n\n${lines.join("\n\n")}${tipsText}`,
-              },
-            ],
+            content: [{ type: "text", text: responseText }],
             details: {
-              candidates: rawCandidates,
-              hits: filteredHits.map((h) => {
-                let effectiveTaskId = h.taskId;
-                if (effectiveTaskId) {
-                  const t = store.getTask(effectiveTaskId);
-                  if (t && t.status === "skipped") effectiveTaskId = null;
-                }
-                return {
-                  chunkId: h.ref.chunkId,
-                  taskId: effectiveTaskId,
-                  skillId: h.skillId,
-                  role: h.source.role,
-                  score: h.score,
-                  summary: h.summary,
-                  original_excerpt: (h.original_excerpt ?? "").slice(0, 200),
-                  origin: h.origin || "local",
-                };
-              }),
+              candidates: rawLocalCandidates,
+              hubCandidates: rawHubCandidates,
+              filtered: filteredDetails,
               meta: result.meta,
             },
           };
@@ -713,14 +686,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 +752,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 +927,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.` }],
@@ -1609,16 +1585,32 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
               };
             }
 
-            const localText = localHits.length > 0
-              ? localHits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)}${h.visibility === "public" ? " (shared to local agents)" : ""}`).join("\n")
+            let filteredLocal = localHits;
+            let filteredHub = hub.hits;
+            if (localHits.length > 0 && hub.hits.length > 0) {
+              const allCandidates = [
+                ...localHits.map((h, i) => ({ index: i + 1, role: "skill" as const, content: `[${h.name}] ${h.description.slice(0, 200)}` })),
+                ...hub.hits.map((h, i) => ({ index: localHits.length + i + 1, role: "skill" as const, content: `[${h.name}] ${h.description.slice(0, 200)}` })),
+              ];
+              const mergedFilter = await summarizer.filterRelevant(skillQuery, allCandidates);
+              if (mergedFilter !== null && mergedFilter.relevant.length > 0) {
+                const relevantSet = new Set(mergedFilter.relevant);
+                filteredLocal = localHits.filter((_, i) => relevantSet.has(i + 1));
+                filteredHub = hub.hits.filter((_, i) => relevantSet.has(localHits.length + i + 1));
+                ctx.log.debug(`skill_search LLM filter (merged): local ${localHits.length}→${filteredLocal.length}, hub ${hub.hits.length}→${filteredHub.length}`);
+              }
+            }
+
+            const localText = filteredLocal.length > 0
+              ? filteredLocal.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)}${h.visibility === "public" ? " (shared to local agents)" : ""}`).join("\n")
               : "(none)";
-            const hubText = hub.hits.length > 0
-              ? hub.hits.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)} (${h.visibility}${h.groupName ? `:${h.groupName}` : ""}, owner=${h.ownerName})`).join("\n")
+            const hubText = filteredHub.length > 0
+              ? filteredHub.map((h, i) => `${i + 1}. [${h.name}] ${h.description.slice(0, 150)} (${h.visibility}${h.groupName ? `:${h.groupName}` : ""}, owner=${h.ownerName})`).join("\n")
               : "(none)";
 
             return {
               content: [{ type: "text", text: `Local skills:\n${localText}\n\nHub skills:\n${hubText}` }],
-              details: { query: skillQuery, scope: rawScope, local: { hits: localHits }, hub },
+              details: { query: skillQuery, scope: rawScope, local: { hits: filteredLocal }, hub: { hits: filteredHub } },
             };
           }
 
@@ -1781,7 +1773,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;
 
@@ -1823,46 +1815,53 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         }
         ctx.log.debug(`auto-recall: query="${query.slice(0, 80)}"`);
 
-        const result = await engine.search({ query, maxResults: 10, minScore: 0.45, ownerFilter: recallOwnerFilter });
+        // ── Phase 1: Local search ∥ Hub search (parallel) ──
+        const arLocalP = engine.search({ query, maxResults: 10, minScore: 0.45, ownerFilter: recallOwnerFilter });
+        const arHubP = ctx.config?.sharing?.enabled
+          ? hubSearchMemories(store, ctx, { query, maxResults: 10, scope: "all" })
+              .catch((err: any) => { ctx.log.debug(`auto-recall: hub search failed (${err})`); return { hits: [] as any[], meta: {} }; })
+          : Promise.resolve({ hits: [] as any[], meta: {} });
+
+        const [result, arHubResult] = await Promise.all([arLocalP, arHubP]);
+
+        const localHits = result.hits.filter((h) => h.origin !== "hub-memory");
+        const hubLocalHits = result.hits.filter((h) => h.origin === "hub-memory");
+        const hubRemoteHits: SearchHit[] = (arHubResult.hits ?? []).map((h: any) => ({
+          summary: h.summary,
+          original_excerpt: h.excerpt || h.summary,
+          ref: { sessionKey: "", chunkId: h.remoteHitId ?? "", turnId: "", seq: 0 },
+          score: 0.9,
+          taskId: null,
+          skillId: null,
+          origin: "hub-remote" as const,
+          source: { ts: h.source?.ts, role: h.source?.role ?? "assistant", sessionKey: "" },
+          ownerName: h.ownerName,
+          groupName: h.groupName,
+        }));
+        const allHubHits = [...hubLocalHits, ...hubRemoteHits];
 
-        // Hub fallback helper: search team shared memories when local search has no relevant results
-        const hubFallback = async (): Promise<SearchHit[]> => {
-          if (!ctx.config?.sharing?.enabled) return [];
-          try {
-            const hubResult = await hubSearchMemories(store, ctx, { query, maxResults: 10, scope: "all" });
-            if (hubResult.hits.length === 0) return [];
-            ctx.log.debug(`auto-recall: hub fallback returned ${hubResult.hits.length} hit(s)`);
-            return hubResult.hits.map((h) => ({
-              summary: h.summary,
-              original_excerpt: h.excerpt || h.summary,
-              ref: { sessionKey: "", chunkId: h.remoteHitId, turnId: "", seq: 0 },
-              score: 0.9,
-              taskId: null,
-              skillId: null,
-              origin: "hub-remote" as const,
-              source: { ts: h.source.ts, role: h.source.role, sessionKey: "" },
-            }));
-          } catch (err) {
-            ctx.log.debug(`auto-recall: hub fallback failed (${err})`);
-            return [];
-          }
-        };
+        ctx.log.debug(`auto-recall: local=${localHits.length}, hub-memory=${hubLocalHits.length}, hub-remote=${hubRemoteHits.length}`);
 
-        if (result.hits.length === 0) {
-          // Local found nothing — try hub before giving up
-          const hubHits = await hubFallback();
-          if (hubHits.length > 0) {
-            result.hits.push(...hubHits);
-            ctx.log.debug(`auto-recall: local empty, using ${hubHits.length} hub hit(s)`);
-          }
-        }
-        if (result.hits.length === 0) {
+        const rawLocalCandidates = localHits.map((h) => ({
+          score: h.score, role: h.source.role, summary: h.summary,
+          content: (h.original_excerpt ?? "").slice(0, 200), origin: h.origin || "local",
+        }));
+        const rawHubCandidates = allHubHits.map((h) => ({
+          score: h.score, role: h.source.role, summary: h.summary,
+          content: (h.original_excerpt ?? "").slice(0, 200), origin: h.origin || "hub-remote",
+          ownerName: (h as any).ownerName ?? "", groupName: (h as any).groupName ?? "",
+        }));
+
+        const allRawHits = [...localHits, ...allHubHits];
+
+        if (allRawHits.length === 0) {
           ctx.log.debug("auto-recall: no memory candidates found");
           const dur = performance.now() - recallT0;
           store.recordToolCall("memory_search", dur, true);
-          store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({ candidates: [], filtered: [] }), dur, true);
+          store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
+            candidates: rawLocalCandidates, hubCandidates: rawHubCandidates, filtered: [],
+          }), dur, true);
 
-          // Even without memory hits, try skill recall
           const skillAutoRecallEarly = ctx.config.skillEvolution?.autoRecallSkills ?? DEFAULTS.skillAutoRecall;
           if (skillAutoRecallEarly) {
             try {
@@ -1902,59 +1901,44 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
           return;
         }
 
-        const candidates = result.hits.map((h, i) => ({
+        // ── Phase 2: Merge all → single LLM filter ──
+        const mergedForFilter = allRawHits.map((h, i) => ({
           index: i + 1,
           role: h.source.role,
           content: (h.original_excerpt ?? "").slice(0, 300),
           time: h.source.ts ? new Date(h.source.ts).toISOString().slice(0, 16) : "",
         }));
 
-        let filteredHits = result.hits;
+        let filteredHits = allRawHits;
         let sufficient = false;
 
-        const filterResult = await summarizer.filterRelevant(query, candidates);
+        const filterResult = await summarizer.filterRelevant(query, mergedForFilter);
         if (filterResult !== null) {
           sufficient = filterResult.sufficient;
           if (filterResult.relevant.length > 0) {
             const indexSet = new Set(filterResult.relevant);
-            filteredHits = result.hits.filter((_, i) => indexSet.has(i + 1));
+            filteredHits = allRawHits.filter((_, i) => indexSet.has(i + 1));
           } else {
-            ctx.log.debug("auto-recall: LLM filter returned no relevant local hits, trying hub fallback");
-            const hubHits = await hubFallback();
-            if (hubHits.length > 0) {
-              ctx.log.debug(`auto-recall: hub fallback provided ${hubHits.length} hit(s) after local filter yielded 0`);
-              filteredHits = hubHits;
-            } else {
-              const dur = performance.now() - recallT0;
-              store.recordToolCall("memory_search", dur, true);
-              store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
-                candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
-                filtered: []
-              }), dur, true);
-              if (query.length > 50) {
-                const noRecallHint =
-                  "## Memory system — ACTION REQUIRED\n\n" +
-                  "Auto-recall found no relevant results for a long query. " +
-                  "You MUST call `memory_search` now with a shortened query (2-5 key words) before answering. " +
-                  "Do NOT skip this step. Do NOT answer without searching first.";
-                return { prependContext: noRecallHint };
-              }
-              return;
+            const dur = performance.now() - recallT0;
+            store.recordToolCall("memory_search", dur, true);
+            store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
+              candidates: rawLocalCandidates, hubCandidates: rawHubCandidates, filtered: [],
+            }), dur, true);
+            if (query.length > 50) {
+              const noRecallHint =
+                "## Memory system — ACTION REQUIRED\n\n" +
+                "Auto-recall found no relevant results for a long query. " +
+                "You MUST call `memory_search` now with a shortened query (2-5 key words) before answering. " +
+                "Do NOT skip this step. Do NOT answer without searching first.";
+              return { prependContext: noRecallHint };
             }
-          }
-        }
-
-        if (!sufficient && filteredHits.length > 0 && ctx.config?.sharing?.enabled) {
-          const hubSupp = await hubFallback();
-          if (hubSupp.length > 0) {
-            ctx.log.debug(`auto-recall: local insufficient, supplementing with ${hubSupp.length} hub hit(s)`);
-            filteredHits.push(...hubSupp);
+            return;
           }
         }
 
         const beforeDedup = filteredHits.length;
         filteredHits = deduplicateHits(filteredHits);
-        ctx.log.debug(`auto-recall: ${result.hits.length} → ${beforeDedup} relevant → ${filteredHits.length} after dedup, sufficient=${sufficient}`);
+        ctx.log.debug(`auto-recall: merged ${allRawHits.length} → ${beforeDedup} relevant → ${filteredHits.length} after dedup, sufficient=${sufficient}`);
 
         const lines = filteredHits.map((h, i) => {
           const excerpt = h.original_excerpt;
@@ -2068,8 +2052,9 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         const recallDur = performance.now() - recallT0;
         store.recordToolCall("memory_search", recallDur, true);
         store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
-          candidates: result.hits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
-          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" }))
+          candidates: rawLocalCandidates,
+          hubCandidates: rawHubCandidates,
+          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
         }), recallDur, true);
         telemetry.trackAutoRecall(filteredHits.length, recallDur);
 
@@ -2245,6 +2230,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 +2243,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 +2282,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}`);
         }