@memorycrystal/crystal-memory 0.7.5 → 0.7.6

package/index.js

@@ -155,6 +155,7 @@ let localStore = null;
 let compactionEngine = null;
 let storeInitPromise = null;
 let localToolsRegistered = false;
+const SHARED_AGENT_SESSION_RE = /^agent:[^:]+:main$/;
 function sanitizeForInjection(text) {
   let value = String(text || "");
   for (const pattern of INJECTION_TAG_PATTERNS) value = value.replace(pattern, "");
@@ -423,6 +424,36 @@ function formatMessageMatch(m) {
 function getSessionKey(ctx, event) {
   return ctx?.sessionKey || ctx?.sessionId || ctx?.conversationId || event?.sessionKey || event?.conversationId || event?.sessionId || "";
 }
+function isSharedAgentSession(sessionKey) {
+  return typeof sessionKey === "string" && SHARED_AGENT_SESSION_RE.test(sessionKey);
+}
+function normalizeScopedChannelKey(channelKey, channelScope) {
+  const scope = typeof channelScope === "string" ? channelScope.trim() : "";
+  const value = typeof channelKey === "string" ? channelKey.trim() : "";
+  if (!scope || !value.startsWith(`${scope}:`)) return "";
+  const peerId = value.slice(scope.length + 1).trim();
+  if (!peerId || peerId === "main" || peerId === "default" || peerId === "unknown") return "";
+  return value;
+}
+function resolveEffectiveChannel(ctx, event, fallbackScope) {
+  const channelScope = getScopedChannelScope(ctx, event, fallbackScope);
+  const explicitChannel = firstString(
+    event?.channel,
+    event?.channelKey,
+    event?.context?.channel,
+    ctx?.channel,
+    ctx?.channelKey
+  );
+  const scopedExplicit = normalizeScopedChannelKey(explicitChannel, channelScope);
+  if (scopedExplicit) return scopedExplicit;
+  return resolveChannelKey(ctx, event, channelScope);
+}
+function resolveLocalContextKey(sessionKey, channelKey, channelScope) {
+  const scopedChannel = normalizeScopedChannelKey(channelKey, channelScope);
+  if (scopedChannel) return scopedChannel;
+  if (channelScope && isSharedAgentSession(sessionKey)) return "";
+  return sessionKey || "";
+}
 function getScopedChannelScope(ctx, event, fallbackScope) {
   const sessionKey = getSessionKey(ctx, event);
   if (sessionKey && sessionChannelScopes.has(sessionKey)) return sessionChannelScopes.get(sessionKey);
@@ -446,11 +477,12 @@ async function logMessage(api, ctx, payload) {
 }
 async function captureTurn(api, event, ctx, userMessage, assistantText) {
   if (!shouldCapture(userMessage, assistantText)) return;
-  await request(getPluginConfig(api, ctx), "POST", "/api/mcp/capture", {
+  const config = getPluginConfig(api, ctx);
+  await request(config, "POST", "/api/mcp/capture", {
     title: `OpenClaw — ${new Date().toISOString().slice(0, 16).replace("T", " ")}`,
     content: [userMessage ? `User: ${userMessage}` : null, `Assistant: ${assistantText}`].filter(Boolean).join("\n\n"),
     store: "sensory", category: "conversation", tags: ["openclaw", "auto-capture"],
-    channel: resolveChannelKey(ctx, event, getPluginConfig(api, ctx)?.channelScope),
+    channel: resolveEffectiveChannel(ctx, event, config?.channelScope),
   }, api.logger);
 }
 async function flushContextEngineMessages(api, ctx, sessionKey, eventLike) {
@@ -459,7 +491,8 @@ async function flushContextEngineMessages(api, ctx, sessionKey, eventLike) {
   // Atomic swap-and-clear: grab the buffer and delete immediately before async I/O
   // to prevent concurrent calls from double-processing the same messages.
   pendingContextEngineMessages.delete(sessionKey);
-  const channelKey = resolveChannelKey(ctx, eventLike || { sessionKey }, getPluginConfig(api, ctx)?.channelScope);
+  const config = getPluginConfig(api, ctx);
+  const channelKey = resolveEffectiveChannel(ctx, eventLike || { sessionKey }, config?.channelScope);
   for (const msg of buffered) {
     await logMessage(api, ctx, { role: msg.role, content: msg.content, channel: channelKey, sessionKey });
   }
@@ -471,7 +504,7 @@ async function flushContextEngineMessages(api, ctx, sessionKey, eventLike) {
 async function buildBeforeAgentContext(api, event, ctx) {
   const config = getPluginConfig(api, ctx);
   if (!config?.apiKey || config.apiKey === "local") return "";
-  const channel = resolveChannelKey(ctx, event, getPluginConfig(api, ctx)?.channelScope);
+  const channel = resolveEffectiveChannel(ctx, event, config?.channelScope);
   const sessionKey = getSessionKey(ctx, event);
   const cronMode = isCronOrIsolated(ctx, event);
   const sections = cronMode ? [] : [PREAMBLE_BACKEND, PREAMBLE_TOOLS];
@@ -514,8 +547,20 @@ async function buildBeforeAgentContext(api, event, ctx) {
   const prompt = String(event?.prompt || "").trim();
   if (prompt.length >= 5) {
     const limit = Math.max(1, Math.min(Number.isFinite(Number(config?.defaultRecallLimit)) ? Number(config.defaultRecallLimit) : 5, 8));
-    const recall = await request(config, "POST", "/api/mcp/recall", { query: prompt, limit, channel, mode: config?.defaultRecallMode || "general" }, api.logger);
-    const mems = Array.isArray(recall?.memories) ? recall.memories.slice(0, 5) : [];
+    const recall = await request(config, "POST", "/api/mcp/recall", { query: prompt, limit: limit + 5, channel, mode: config?.defaultRecallMode || "general" }, api.logger);
+    let mems = Array.isArray(recall?.memories) ? recall.memories : [];
+    // --- Channel isolation: drop cross-client memories in peer-scoped sessions ---
+    // When channel is peer-specific (e.g. "morrow-coach:12345"), exclude non-KB
+    // memories with continuityScore===0 — they belong to other clients/sessions.
+    // KB memories (knowledgeBaseId set) are allowed through since they're curated content.
+    if (channel && channel.includes(":")) {
+      mems = mems.filter(m => {
+        if (m.knowledgeBaseId) return true; // KB content is always allowed
+        const cont = m.rankingSignals?.continuityScore ?? m.continuityScore;
+        return cont !== 0;
+      });
+    }
+    mems = mems.slice(0, 5);
     // --- Organic: log recall query (fire-and-forget) ---
     request(config, "POST", "/api/organic/recallLog", { query: prompt, resultCount: mems.length, source: "plugin" }, api.logger).catch(() => {});
     // Cache top recall results for reinforcement injection later in the conversation
@@ -531,34 +576,37 @@ async function buildBeforeAgentContext(api, event, ctx) {
       sections.push(["## Memory Crystal Relevant Recall", `Prompt: ${trimSnippet(prompt, 180)}`, ...mems.map(formatRecallMemory), "", "Use memory_search for broader lookup and memory_get on the returned crystal/<id>.md path for full detail.", recallDirective].join("\n"));
     }
     if (!cronMode) {
-      const msgS = await request(config, "POST", "/api/mcp/search-messages", { query: prompt, limit: 5, channel }, api.logger);
-      const msgs = Array.isArray(msgS?.messages) ? msgS.messages.slice(0, 5) : [];
-      if (msgs.length) sections.push(["## Memory Crystal Recent Message Matches", `Prompt: ${trimSnippet(prompt, 180)}`, ...msgs.map(formatMessageMatch)].join("\n"));
+      const isPeerScopedChannel = channel && channel.includes(":");
+      if (!isPeerScopedChannel) {
+        const msgS = await request(config, "POST", "/api/mcp/search-messages", { query: prompt, limit: 5, channel }, api.logger);
+        const msgs = Array.isArray(msgS?.messages) ? msgS.messages.slice(0, 5) : [];
+        if (msgs.length) sections.push(["## Memory Crystal Recent Message Matches", `Prompt: ${trimSnippet(prompt, 180)}`, ...msgs.map(formatMessageMatch)].join("\n"));
 
-      // Token-budgeted recent message window (~7k chars): fetch up to 30 recent
-      // messages ordered by time, trim from oldest until we fit the budget.
-      const RECENT_CHAR_BUDGET = 7000;
-      const recentR = await request(config, "POST", "/api/mcp/recent-messages", { limit: 30, channel }, api.logger);
-      const recentRaw = Array.isArray(recentR?.messages) ? recentR.messages : [];
-      if (recentRaw.length) {
-        // Build lines from the ascending list (oldest-first from backend)
-        const lines = recentRaw.map(m => {
-          const role = m.role === "assistant" ? "assistant" : "user";
-          const ts = m.createdAt ? new Date(m.createdAt).toLocaleTimeString("en-CA", { hour: "2-digit", minute: "2-digit" }) : "";
-          const snippet = sanitizeForInjection(String(m.content || m.text || "")).replace(/\n+/g, " ").trim().slice(0, 400);
-          return `[${ts}] ${role}: ${snippet}`;
-        });
-        // Iterate from end (newest) to keep most recent messages on budget overflow
-        const kept = [];
-        let chars = 0;
-        for (let i = lines.length - 1; i >= 0; i--) {
-          if (chars + lines[i].length + 1 > RECENT_CHAR_BUDGET) break;
-          kept.push(lines[i]);
-          chars += lines[i].length + 1;
-        }
-        if (kept.length) {
-          kept.reverse(); // restore chronological order for injection
-          sections.push(["## Memory Crystal Recent Context (last messages)", ...kept].join("\n"));
+        // Token-budgeted recent message window (~7k chars): fetch up to 30 recent
+        // messages ordered by time, trim from oldest until we fit the budget.
+        const RECENT_CHAR_BUDGET = 7000;
+        const recentR = await request(config, "POST", "/api/mcp/recent-messages", { limit: 30, channel }, api.logger);
+        const recentRaw = Array.isArray(recentR?.messages) ? recentR.messages : [];
+        if (recentRaw.length) {
+          // Build lines from the ascending list (oldest-first from backend)
+          const lines = recentRaw.map(m => {
+            const role = m.role === "assistant" ? "assistant" : "user";
+            const ts = m.createdAt ? new Date(m.createdAt).toLocaleTimeString("en-CA", { hour: "2-digit", minute: "2-digit" }) : "";
+            const snippet = sanitizeForInjection(String(m.content || m.text || "")).replace(/\n+/g, " ").trim().slice(0, 400);
+            return `[${ts}] ${role}: ${snippet}`;
+          });
+          // Iterate from end (newest) to keep most recent messages on budget overflow
+          const kept = [];
+          let chars = 0;
+          for (let i = lines.length - 1; i >= 0; i--) {
+            if (chars + lines[i].length + 1 > RECENT_CHAR_BUDGET) break;
+            kept.push(lines[i]);
+            chars += lines[i].length + 1;
+          }
+          if (kept.length) {
+            kept.reverse(); // restore chronological order for injection
+            sections.push(["## Memory Crystal Recent Context (last messages)", ...kept].join("\n"));
+          }
         }
       }
     }
@@ -747,7 +795,10 @@ module.exports = (api) => {
     try {
       const text = extractUserText(event);
       const sessionKey = getSessionKey(ctx, event);
-      const channelKey = resolveChannelKey(ctx, event, getPluginConfig(api, ctx)?.channelScope);
+      const config = getPluginConfig(api, ctx);
+      const channelScope = getScopedChannelScope(ctx, event, config?.channelScope);
+      const channelKey = resolveEffectiveChannel(ctx, event, config?.channelScope);
+      const localContextKey = resolveLocalContextKey(sessionKey, channelKey, channelScope);
       api.logger?.warn?.(`[crystal] message_received session=${sessionKey || "?"} channel=${channelKey || "?"} textLen=${String(text || "").length}`);
       if (!seenCaptureSessions.has(`msg:${sessionKey}`)) seenCaptureSessions.add(`msg:${sessionKey}`);
       if (text && sessionKey) pendingUserMessages.set(sessionKey, String(text));
@@ -757,10 +808,10 @@ module.exports = (api) => {
         intentCache.set(sessionKey, { intent, detectedAt: Date.now() });
       }
       if (text) await logMessage(api, ctx, { role: "user", content: String(text), channel: channelKey, sessionKey: sessionKey || undefined });
-      const store = await getLocalStore(getPluginConfig(api, ctx), api.logger);
-      if (store && text && sessionKey) { store.addMessage(sessionKey, "user", String(text)); _registerLocalTools(api); }
-      if (sessionKey) sessionConfigs.set(sessionKey, { mode: getPluginConfig(api, ctx)?.defaultRecallMode || "general", limit: getPluginConfig(api, ctx)?.defaultRecallLimit || 8 });
-      fireMediaCapture(event, getPluginConfig(api, ctx), channelKey, sessionKey);
+      const store = await getLocalStore(config, api.logger);
+      if (store && text && localContextKey) { store.addMessage(localContextKey, "user", String(text)); _registerLocalTools(api); }
+      if (sessionKey) sessionConfigs.set(sessionKey, { mode: config?.defaultRecallMode || "general", limit: config?.defaultRecallLimit || 8 });
+      fireMediaCapture(event, config, channelKey, sessionKey);
       if (text && sessionKey) triggerConversationPulse(api, ctx, sessionKey, String(text));
     } catch (err) { api.logger?.warn?.(`[crystal] message_received: ${getErrorMessage(err)}`); }
   }, { name: "crystal-memory.message-received", description: "Buffer + persist user turn" });
@@ -768,17 +819,20 @@ module.exports = (api) => {
     try {
       const assistantText = extractAssistantText(event);
       const sessionKey = getSessionKey(ctx, event);
-      const channelKey = resolveChannelKey(ctx, event, getPluginConfig(api, ctx)?.channelScope);
+      const config = getPluginConfig(api, ctx);
+      const channelScope = getScopedChannelScope(ctx, event, config?.channelScope);
+      const channelKey = resolveEffectiveChannel(ctx, event, config?.channelScope);
+      const localContextKey = resolveLocalContextKey(sessionKey, channelKey, channelScope);
       if (!seenCaptureSessions.has(`out:${sessionKey}`)) { seenCaptureSessions.add(`out:${sessionKey}`); api.logger?.info?.(`[crystal] llm_output session=${sessionKey}`); }
       if (!assistantText) { api.logger?.warn?.("[crystal] llm_output missing assistant text"); return; }
       const userMessage = sessionKey ? pendingUserMessages.get(sessionKey) || "" : "";
       await logMessage(api, ctx, { role: "assistant", content: assistantText, channel: channelKey, sessionKey: sessionKey || undefined });
-      const store = await getLocalStore(getPluginConfig(api, ctx), api.logger);
-      if (store && sessionKey) { store.addMessage(sessionKey, "assistant", assistantText); _registerLocalTools(api); }
+      const store = await getLocalStore(config, api.logger);
+      if (store && localContextKey) { store.addMessage(localContextKey, "assistant", assistantText); _registerLocalTools(api); }
       if (sessionKey) appendConversationPulseMessage(sessionKey, "assistant", assistantText);
       if (sessionKey) pendingUserMessages.delete(sessionKey);
       await captureTurn(api, event, ctx, userMessage, assistantText);
-      fireMediaCapture(event, getPluginConfig(api, ctx), channelKey, sessionKey);
+      fireMediaCapture(event, config, channelKey, sessionKey);
     } catch (err) { api.logger?.warn?.(`[crystal] llm_output: ${getErrorMessage(err)}`); }
   }, { name: "crystal-memory.llm-output", description: "Capture AI response" });
   hook("message_sent", async (event, ctx) => {
@@ -787,10 +841,14 @@ module.exports = (api) => {
       if (!sessionKey || !pendingUserMessages.has(sessionKey)) return;
       const assistantText = extractAssistantText(event);
       if (!assistantText) return;
+      const config = getPluginConfig(api, ctx);
+      const channelScope = getScopedChannelScope(ctx, event, config?.channelScope);
+      const channelKey = resolveEffectiveChannel(ctx, event, config?.channelScope);
+      const localContextKey = resolveLocalContextKey(sessionKey, channelKey, channelScope);
       const userMessage = pendingUserMessages.get(sessionKey) || "";
-      await logMessage(api, ctx, { role: "assistant", content: assistantText, channel: resolveChannelKey(ctx, event, getPluginConfig(api, ctx)?.channelScope), sessionKey });
-      const store = await getLocalStore(getPluginConfig(api, ctx), api.logger);
-      if (store) { store.addMessage(sessionKey, "assistant", assistantText); _registerLocalTools(api); }
+      await logMessage(api, ctx, { role: "assistant", content: assistantText, channel: channelKey, sessionKey });
+      const store = await getLocalStore(config, api.logger);
+      if (store && localContextKey) { store.addMessage(localContextKey, "assistant", assistantText); _registerLocalTools(api); }
       appendConversationPulseMessage(sessionKey, "assistant", assistantText);
       pendingUserMessages.delete(sessionKey);
       await captureTurn(api, event, ctx, userMessage, assistantText);
@@ -818,12 +876,16 @@ module.exports = (api) => {
           const sessionKey = firstString(payload?.sessionKey, ctx?.sessionKey, ctx?.sessionId);
           const messages = Array.isArray(payload?.messages) ? payload.messages : [];
           queueContextEngineMessages(sessionKey, messages);
-          const flushed = await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey });
-          const store = await getLocalStore(getPluginConfig(api, ctx), api.logger);
+          const pluginCfg = getPluginConfig(api, ctx);
+          const channelScope = getScopedChannelScope(ctx, { sessionKey }, pluginCfg?.channelScope);
+          const channelKey = firstString(payload?.channel, resolveEffectiveChannel(ctx, { sessionKey, channel: payload?.channel }, pluginCfg?.channelScope));
+          const flushed = await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey, channel: channelKey });
+          const store = await getLocalStore(pluginCfg, api.logger);
           if (store && sessionKey) {
+            const localContextKey = resolveLocalContextKey(sessionKey, channelKey, channelScope);
             for (const msg of messages) {
               const nm = normalizeContextEngineMessage(msg);
-              if (nm && (nm.role === "user" || nm.role === "assistant")) store.addMessage(sessionKey, nm.role, nm.content);
+              if (nm && localContextKey && (nm.role === "user" || nm.role === "assistant")) store.addMessage(localContextKey, nm.role, nm.content);
             }
             _registerLocalTools(api);
           }
@@ -836,17 +898,21 @@ module.exports = (api) => {
           const budget = Number.isFinite(Number(payload?.tokenBudget)) ? Number(payload.tokenBudget) : Infinity;
           const sessionKey = firstString(payload?.sessionKey, payload?.sessionId, ctx?.sessionKey, ctx?.sessionId) || "default";
           const pluginCfg = getPluginConfig(api, ctx);
+          const channelScope = getScopedChannelScope(ctx, { sessionKey }, pluginCfg?.channelScope);
+          const channelKey = resolveEffectiveChannel(ctx, { sessionKey, channel: payload?.channel }, pluginCfg?.channelScope);
+          const localContextKey = resolveLocalContextKey(sessionKey, channelKey, channelScope);
           const injectionEnabled = pluginCfg.localSummaryInjection !== false;
           const injectionBudget = pluginCfg.localSummaryMaxTokens || 2000;
           const syntheticEvent = {
             prompt: messages.map((m) => normalizeContextEngineMessage(m, m?.role || "user")?.content || "").filter(Boolean).slice(-6).join("\n\n"),
             sessionKey,
+            ...(channelKey ? { channel: channelKey } : {}),
           };
           let localMessages = [];
           const store = localStore || await getLocalStore(pluginCfg, api.logger);
-          if (store && sessionKey) {
+          if (store && localContextKey) {
             try {
-              const assembled = await assembleContext(store, sessionKey, budget, undefined, {
+              const assembled = await assembleContext(store, localContextKey, budget, undefined, {
                 localSummaryInjection: injectionEnabled,
                 localSummaryMaxTokens: injectionBudget,
               });
@@ -860,9 +926,9 @@ module.exports = (api) => {
             ? [...systemMsg, ...localMessages, ...messages.slice(-TAIL_KEEP)]
             : [...systemMsg, ...localMessages, ...messages];
           try {
-            const store = localStore || await getLocalStore(getPluginConfig(api, ctx), api.logger);
-            if (store && sessionKey) {
-              const hotTopics = store.getLessonCountsForSession(sessionKey, 3);
+            const store = localStore || await getLocalStore(pluginCfg, api.logger);
+            if (store && localContextKey) {
+              const hotTopics = store.getLessonCountsForSession(localContextKey, 3);
               if (hotTopics.length > 0) {
                 const warnings = hotTopics.map((r) => `CIRCUIT BREAKER: You have saved ${r.count} lessons about "${r.topic}" in this session. This suggests repeated failures. Stop and ask your human for guidance before continuing.`).join("\n");
                 finalMessages.unshift({ role: "system", content: warnings });
@@ -883,12 +949,15 @@ module.exports = (api) => {
           const sessionKey = firstString(payload?.sessionKey, ctx?.sessionKey, ctx?.sessionId);
           const messages = Array.isArray(payload?.messages) ? payload.messages : [];
           queueContextEngineMessages(sessionKey, messages);
-          const flushed = await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey });
+          const pluginCfg = getPluginConfig(api, ctx);
+          const channelScope = getScopedChannelScope(ctx, { sessionKey }, pluginCfg?.channelScope);
+          const channel = firstString(payload?.channel, resolveEffectiveChannel(ctx, { sessionKey, channel: payload?.channel }, pluginCfg?.channelScope));
+          const localContextKey = resolveLocalContextKey(sessionKey, channel, channelScope);
+          const flushed = await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey, channel });
           let summaryCount = 0;
-          if (compactionEngine && sessionKey) { try { summaryCount = (await compactionEngine.compact(sessionKey, 32000, compactionEngine._summarizeFn, false))?.summariesCreated ?? 0; } catch (_) {} }
+          if (compactionEngine && localContextKey) { try { summaryCount = (await compactionEngine.compact(localContextKey, 32000, compactionEngine._summarizeFn, false))?.summariesCreated ?? 0; } catch (_) {} }
           const label = `OpenClaw compaction — ${new Date().toISOString()}`;
-          const cfg = getPluginConfig(api, ctx);
-          const channel = firstString(payload?.channel, resolveChannelKey(ctx, { sessionKey }, getPluginConfig(api, ctx)?.channelScope));
+          const cfg = pluginCfg;
           // Snapshot the full conversation before compaction (non-fatal — failure won't break compaction)
           let snapshotId = null;
           try {
@@ -914,8 +983,12 @@ module.exports = (api) => {
       async afterTurn(payload, ctx) {
         try {
           const sessionKey = firstString(payload?.sessionKey, ctx?.sessionKey, ctx?.sessionId);
-          await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey });
-          if (compactionEngine && sessionKey) { try { await compactionEngine.compactLeaf(sessionKey, compactionEngine._summarizeFn); } catch (_) {} }
+          const pluginCfg = getPluginConfig(api, ctx);
+          const channelScope = getScopedChannelScope(ctx, { sessionKey }, pluginCfg?.channelScope);
+          const channel = resolveEffectiveChannel(ctx, { sessionKey, channel: payload?.channel }, pluginCfg?.channelScope);
+          const localContextKey = resolveLocalContextKey(sessionKey, channel, channelScope);
+          await flushContextEngineMessages(api, ctx, sessionKey, { sessionKey, channel });
+          if (compactionEngine && localContextKey) { try { await compactionEngine.compactLeaf(localContextKey, compactionEngine._summarizeFn); } catch (_) {} }
           if (localStore) _registerLocalTools(api);
         } catch (err) { api.logger?.warn?.(`[crystal] afterTurn: ${getErrorMessage(err)}`); }
       },
@@ -1055,14 +1128,16 @@ module.exports = (api) => {
   api.registerTool({
     name: "crystal_what_do_i_know", label: "Crystal What Do I Know",
     description: "Get a broad snapshot of what Memory Crystal contains about a topic.",
-    parameters: { type: "object", properties: { topic: { type: "string", minLength: 3 }, limit: { type: "number", minimum: 1, maximum: 20 } }, required: ["topic"], additionalProperties: false },
+    parameters: { type: "object", properties: { topic: { type: "string", minLength: 3 }, stores: { type: "array", items: { type: "string", enum: MEMORY_STORES } }, tags: { type: "array", items: { type: "string" } }, limit: { type: "number", minimum: 1, maximum: 20 } }, required: ["topic"], additionalProperties: false },
     async execute(_id, params, _sig, _upd, ctx) {
       try {
         const topic = ensureString(params?.topic, "topic", 3);
         const limit = Number.isFinite(Number(params?.limit)) ? Number(params.limit) : 8;
+        const stores = Array.isArray(params?.stores) ? params.stores : undefined;
+        const tags = Array.isArray(params?.tags) ? params.tags.map(String).filter(Boolean) : undefined;
         const cfg = getPluginConfig(api, ctx);
         const resolvedChannel = resolveScopedChannelKey(ctx, ctx, cfg?.channelScope);
-        const payload = { query: topic, limit, ...(resolvedChannel ? { channel: resolvedChannel } : {}) };
+        const payload = { query: topic, limit, ...(stores ? { stores } : {}), ...(tags ? { tags } : {}), ...(resolvedChannel ? { channel: resolvedChannel } : {}) };
         const data = await crystalRequest(cfg, "/api/mcp/recall", payload);
         const mems = Array.isArray(data?.memories) ? data.memories : [];
         return toToolResult({ topic, memoryCount: mems.length, summary: mems.slice(0, 3).map((m) => m.title).join("; ") || "No matching memories found.", topMemories: mems.slice(0, 10) });
@@ -1079,11 +1154,10 @@ module.exports = (api) => {
         const limit = Number.isFinite(Number(params?.limit)) ? Number(params.limit) : 8;
         const cfg = getPluginConfig(api, ctx);
         const resolvedChannel = resolveScopedChannelKey(ctx, ctx, cfg?.channelScope);
-        const payload = { query: decision, limit, ...(resolvedChannel ? { channel: resolvedChannel } : {}) };
+        const payload = { query: decision, limit, mode: "decision", categories: ["decision"], stores: MEMORY_STORES, ...(resolvedChannel ? { channel: resolvedChannel } : {}) };
         const data = await crystalRequest(cfg, "/api/mcp/recall", payload);
         const mems = Array.isArray(data?.memories) ? data.memories : [];
-        const related = mems.filter((m) => m?.category === "decision").length > 0 ? mems.filter((m) => m?.category === "decision") : mems;
-        return toToolResult({ decision, reasoning: related.length > 0 ? `Primary threads around "${decision}"` : "No clear decision thread was surfaced.", relatedMemories: related.slice(0, 10) });
+        return toToolResult({ decision, reasoning: mems.length > 0 ? `Primary threads around "${decision}"` : "No clear decision thread was surfaced.", relatedMemories: mems.slice(0, 10) });
       } catch (err) { return toToolError(err); }
     },
   });

package/index.test.js

@@ -327,6 +327,76 @@ describe("crystal-memory plugin — Phase 2 integration", () => {
     }
   });
 
+  test("11c. assemble skips shared agent local summary injection when no concrete client channel is available", async () => {
+    const { checkSqliteAvailability, CrystalLocalStore } = await import(path.resolve(__dirname, "store/crystal-local-store.js"));
+    const avail = checkSqliteAvailability();
+    if (!avail.available) return;
+
+    const dbPath = makeTmpDbPath();
+    try {
+      const seedStore = new CrystalLocalStore();
+      seedStore.init(dbPath);
+      seedStore.insertSummary({
+        summaryId: "sum_shared_agent_1",
+        sessionKey: "agent:coach:main",
+        kind: "leaf",
+        depth: 0,
+        content: "BJ Moffatt private coaching history that must never bleed into another client.",
+        tokenCount: 60,
+      });
+      seedStore.addMessage("agent:coach:main", "user", "BJ Moffatt private coaching history");
+      seedStore.close();
+
+      const api = loadPlugin({ apiKey: "local", dbPath, channelScope: "morrow-coach", localSummaryInjection: true });
+      const engine = api._getEngine();
+      const result = await engine.assemble({
+        sessionKey: "agent:coach:main",
+        messages: [{ role: "user", content: "How should I respond to this client?" }],
+      }, makeCtx({ sessionKey: "agent:coach:main" }));
+
+      assert.equal(
+        result.messages.some((m) => m.role === "system" && m.content.includes("Relevant context from earlier in this conversation")),
+        false
+      );
+      assert.equal(
+        result.messages.some((m) => typeof m.content === "string" && m.content.includes("BJ Moffatt private coaching history")),
+        false
+      );
+    } finally {
+      fs.rmSync(dbPath, { force: true });
+    }
+  });
+
+  test("11d. ingestBatch stores shared coach local context under the concrete scoped channel instead of agent:coach:main", async () => {
+    const { checkSqliteAvailability } = await import(path.resolve(__dirname, "store/crystal-local-store.js"));
+    const avail = checkSqliteAvailability();
+    if (!avail.available) return;
+
+    const dbPath = makeTmpDbPath();
+    try {
+      const api = loadPlugin({ apiKey: "local", dbPath, channelScope: "morrow-coach" });
+      const engine = api._getEngine();
+      await engine.ingestBatch({
+        sessionKey: "agent:coach:main",
+        channel: "morrow-coach:12345",
+        messages: [
+          { role: "user", content: "Andy-specific note" },
+          { role: "assistant", content: "Coach response for Andy" },
+        ],
+      }, makeCtx({ sessionKey: "agent:coach:main" }));
+
+      const db = require("better-sqlite3")(dbPath, { readonly: true });
+      try {
+        const keys = db.prepare("SELECT session_key FROM conversations ORDER BY session_key ASC").all().map((row) => row.session_key);
+        assert.deepEqual(keys, ["morrow-coach:12345"]);
+      } finally {
+        db.close();
+      }
+    } finally {
+      fs.rmSync(dbPath, { force: true });
+    }
+  });
+
   test("9d. crystal_preflight does not classify a lesson as both a rule and a lesson", async () => {
     const api = loadPlugin();
     const tool = api._tools.get("crystal_preflight");
@@ -454,5 +524,38 @@ describe("crystal-memory plugin — Phase 2 integration", () => {
       payload = JSON.parse(fetchCalls.at(-1).opts.body);
       assert.equal(payload.channel, "default-scope:12345");
     });
+
+    test("crystal_set_scope also drives shared-session local context keying", async () => {
+      const { checkSqliteAvailability } = await import(path.resolve(__dirname, "store/crystal-local-store.js"));
+      const avail = checkSqliteAvailability();
+      if (!avail.available) return;
+
+      const dbPath = makeTmpDbPath();
+      try {
+        const api = loadPlugin({ apiKey: "local", dbPath, channelScope: "default-scope" });
+        const ctx = makeCtx({ peerId: "12345", sessionKey: "agent:coach:main" });
+        const setScopeTool = api._tools.get("crystal_set_scope");
+        const engine = api._getEngine();
+
+        await setScopeTool.execute("id", { scope: "morrow-coach" }, null, null, ctx);
+        await engine.ingestBatch({
+          sessionKey: "agent:coach:main",
+          messages: [
+            { role: "user", content: "Andy-specific note" },
+            { role: "assistant", content: "Coach response for Andy" },
+          ],
+        }, ctx);
+
+        const db = require("better-sqlite3")(dbPath, { readonly: true });
+        try {
+          const keys = db.prepare("SELECT session_key FROM conversations ORDER BY session_key ASC").all().map((row) => row.session_key);
+          assert.deepEqual(keys, ["morrow-coach:12345"]);
+        } finally {
+          db.close();
+        }
+      } finally {
+        fs.rmSync(dbPath, { force: true });
+      }
+    });
   });
 });

package/openclaw.plugin.json

@@ -6,7 +6,7 @@
   ],
   "name": "Memory Crystal",
   "description": "Persistent memory for AI agents via Memory Crystal",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "entry": "index.js",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorycrystal/crystal-memory",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Memory Crystal OpenClaw plugin",
   "license": "MIT",
   "main": "index.js",

package/recall-hook.js

@@ -2,10 +2,9 @@
 const fs = require("node:fs");
 const path = require("node:path");
 
-const OPENAI_MODEL = "text-embedding-3-small";
-const OPENAI_URL = "https://api.openai.com/v1/embeddings";
 const GEMINI_MODEL = "gemini-embedding-2-preview";
 const GEMINI_URL_BASE = "https://generativelanguage.googleapis.com/v1beta";
+const REQUIRED_EMBEDDING_DIMENSIONS = 3072;
 const CONVEX_ACTION = "/api/action";
 const CONVEX_QUERY = "/api/query";
 const DEFAULT_LIMIT = 8;
@@ -136,46 +135,26 @@ const getEmbedding = async (query, env) => {
   }
 
   const provider = String(env.EMBEDDING_PROVIDER || "gemini").toLowerCase();
-
-  if (provider === "gemini") {
-    const geminiKey = env.GEMINI_API_KEY;
-    if (!geminiKey) {
-      return null;
-    }
-    const model = env.GEMINI_EMBEDDING_MODEL || GEMINI_MODEL;
-    const response = await fetch(`${GEMINI_URL_BASE}/models/${model}:embedContent?key=${encodeURIComponent(geminiKey)}`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify({
-        model: `models/${model}`,
-        content: { parts: [{ text: query }] },
-      }),
-    });
-
-    if (!response.ok) {
-      return null;
-    }
-
-    const payload = await response.json().catch(() => null);
-    return Array.isArray(payload?.embedding?.values) ? payload.embedding.values : null;
+  if (provider !== "gemini") {
+    throw new Error(
+      `Only Gemini embeddings are supported. Got EMBEDDING_PROVIDER="${provider}". ` +
+      "Set EMBEDDING_PROVIDER=gemini or remove the variable."
+    );
   }
 
-  const openaiKey = env.OPENAI_API_KEY;
-  if (!openaiKey) {
+  const geminiKey = env.CRYSTAL_API_KEY || env.GEMINI_API_KEY;
+  if (!geminiKey) {
     return null;
   }
-
-  const response = await fetch(OPENAI_URL, {
+  const model = env.GEMINI_EMBEDDING_MODEL || GEMINI_MODEL;
+  const response = await fetch(`${GEMINI_URL_BASE}/models/${model}:embedContent?key=${encodeURIComponent(geminiKey)}`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
-      Authorization: `Bearer ${openaiKey}`,
     },
     body: JSON.stringify({
-      model: OPENAI_MODEL,
-      input: query,
+      model: `models/${model}`,
+      content: { parts: [{ text: query }] },
     }),
   });
 
@@ -184,7 +163,15 @@ const getEmbedding = async (query, env) => {
   }
 
   const payload = await response.json().catch(() => null);
-  return Array.isArray(payload?.data?.[0]?.embedding) ? payload.data[0].embedding : null;
+  const vector = Array.isArray(payload?.embedding?.values) ? payload.embedding.values : null;
+
+  if (vector && vector.length !== REQUIRED_EMBEDDING_DIMENSIONS) {
+    throw new Error(
+      `Embedding dimension mismatch in recall-hook: got ${vector.length}, expected ${REQUIRED_EMBEDDING_DIMENSIONS}`
+    );
+  }
+
+  return vector;
 };
 
 const formatBlock = (memories) => {