@hyperspell/openclaw-hyperspell 0.17.0 → 0.18.1

package/dist/commands/setup.js

@@ -277,6 +277,8 @@ async function runSetup() {
                     writeAssistant: true,
                 },
                 emotionalContext: false,
+                moodWeatherChance: 0,
+                excludeChannels: [],
                 syncMemories: true,
                 syncMemoriesConfig: {
                     enabled: true,

package/dist/config.js

@@ -18,6 +18,8 @@ const ALLOWED_KEYS = [
     "autoTrace",
     "hotBuffer",
     "emotionalContext",
+    "moodWeatherChance",
+    "excludeChannels",
     "relationshipId",
     "startupOrientation",
     "syncMemories",
@@ -72,6 +74,7 @@ function parseRanking(raw) {
             ? r.storyTerms.map((t) => String(t)).filter((t) => t.length > 0)
             : DEFAULT_RANKING.storyTerms,
         candidateMultiplier: Math.max(1, num(r.candidateMultiplier, DEFAULT_RANKING.candidateMultiplier)),
+        chatterQuota: Math.max(0, num(r.chatterQuota, DEFAULT_RANKING.chatterQuota)),
     };
 }
 function parseSources(raw) {
@@ -300,6 +303,14 @@ export function parseConfig(raw) {
             writeAssistant: hbRaw.writeAssistant ?? true,
         },
         emotionalContext: cfg.emotionalContext ?? false,
+        // Default 0 (off) so shipping never changes existing installs' behavior.
+        // Clamped to [0,1] so a stray config value can't make every session roll.
+        moodWeatherChance: Math.min(1, Math.max(0, cfg.moodWeatherChance ?? 0)),
+        excludeChannels: Array.isArray(cfg.excludeChannels)
+            ? cfg.excludeChannels
+                .map((c) => String(c).trim())
+                .filter((c) => c.length > 0)
+            : [],
         relationshipId: cfg.relationshipId,
         startupOrientation: {
             enabled: soRaw.enabled ?? false,

package/dist/hooks/auto-context.js

@@ -1,8 +1,9 @@
 import { buildScopeFilter, getCanReadScopes, resolveUser, } from "../lib/sender.js";
 import { excludeFilterFor, mergeWithExclude } from "../lib/filters.js";
-import { rerank } from "../lib/ranking.js";
+import { rerank, selectRanked } from "../lib/ranking.js";
 import { classifySearchError, logSearchError } from "../lib/search-error.js";
 import { resolveCurrentSessionId } from "../lib/session.js";
+import { recordSender, senderIdFromCtx } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 function formatRelativeTime(isoTimestamp) {
     try {
@@ -53,18 +54,14 @@ function formatHighlightBullets(results, maxResults, threshold) {
     return sections.join("\n\n");
 }
 /**
- * Like formatHighlightBullets, but for composite-RANKED results: a result is
- * kept on its composite score (relevance + curation/story boost − chatter), not
- * raw relevance — so a deliberately-kept memory that's quietly relevant clears
- * the bar where a louder conversation echo doesn't. Highlights are floored at
- * the lower of (threshold, the result's own base relevance), so we don't then
- * hide the very lines that define a boosted-but-quiet memory.
+ * Format already-SELECTED composite-ranked results (threshold + chatter quota
+ * applied upstream by selectRanked). Highlights are floored at the lower of
+ * (threshold, the result's own base relevance), so we don't hide the very lines
+ * that define a boosted-but-quiet memory.
  */
-function formatRankedBullets(ranked, maxResults, threshold) {
+function formatSelected(selected, threshold) {
     const sections = [];
-    for (const r of ranked) {
-        if (r._composite < threshold)
-            continue;
+    for (const r of selected) {
         const hiFloor = Math.min(threshold, r._base);
         const chosen = [...r.highlights]
             .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
@@ -77,8 +74,6 @@ function formatRankedBullets(ranked, maxResults, threshold) {
             .map((h) => `- ${h.text.replace(/\n/g, " ")} [${Math.round((h.score ?? 0) * 100)}%]`)
             .join("\n");
         sections.push(`### ${title} (resource_id: ${r.resourceId}, source: ${r.source})\n\n${bullets}`);
-        if (sections.length >= maxResults)
-            break;
     }
     if (sections.length === 0)
         return null;
@@ -86,18 +81,27 @@ function formatRankedBullets(ranked, maxResults, threshold) {
 }
 const INTRO = "The following is surfaced from the user's memory and connected sources, including past conversations. Reference it as recalled context, only when relevant to the conversation.";
 const DISCLAIMER = "Draw on it when relevant — including indirect connections — but don't force it into every response or make assumptions beyond what's stated.";
-// Injected EVERY turn (even when nothing cleared the bar): this passive match is
-// a starting point, not the whole of memory. The point is to make her LOOK —
-// actively search before concluding — rather than answer from whatever happened
-// to surface, which is what lets an agent invent instead of recall.
-const SEARCH_DIRECTIVE = "This is a passive match and may miss what matters. Before answering anything that touches your shared history, a past decision, a name, a promise, or something you may have recorded, run hyperspell_search with a specific query and look — even if something is already shown above. Don't answer from impression when you can check. If a search returns nothing, say so plainly; never fill the gap with something invented.";
-/** Wrap the per-turn context: the standing search directive always, plus the
- * surfaced memory when anything cleared the bar. */
+// A short, CONDITIONAL reminder appended only to a real memory block (not a
+// standing every-turn imperative — that reads as ambient framing and trains
+// search-as-ritual; the agent's own instructions carry the standing rule). The
+// point here is just: what surfaced is a passive match, not all of memory.
+const SEARCH_REMINDER = "This is a passive match, not all of memory — if the answer turns on a specific past decision, promise, name, or something recorded, search for it directly before concluding, and say so plainly if it isn't there.";
+// Explicit authority precedence: live sender metadata outranks surfaced memory
+// for identity questions. Without this, a high-scoring memory naming a different
+// person than the live sender can silently override who the agent thinks it is
+// talking to — the identity-bleed failure observed live (issue #58).
+// Two carve-outs (issue #59 follow-up):
+//   (1) A memory about the CURRENT sender's own past is not a conflict — use it
+//       as recalled personal context. The guard only applies when the identity in
+//       the memory is clearly a different person from the live sender.
+//   (2) Display names and handles often differ across sessions (e.g. "dithilli"
+//       vs "David S"). Use judgment to identify whether a retrieved name refers
+//       to the current speaker before applying the guard.
+const AUTHORITY_GUARD = "AUTHORITY: The live conversation's sender and session metadata always outrank this recalled context for identity — who is speaking right now, their name, role, or relationship. If a surfaced memory names a different person than the current sender, treat it as historical context about someone else, not a description of the current speaker. Do not adopt a persona, name, or backstory from recalled memory that conflicts with the live sender. Exception: a memory about the current sender's own past (their preferences, history, emotional state) is not a conflict — use it as recalled personal context. Display names and handles may differ across sessions; use judgment to identify whether a retrieved name refers to the current speaker before applying this guard.";
+/** Wrap a real memory block. No memory → no injection (caller returns nothing);
+ * the standing search rule lives in the agent's own instructions, not here. */
 function wrapContext(memorySection) {
-    if (memorySection) {
-        return `<hyperspell-context>\n${INTRO}\n\n${memorySection}\n\n${DISCLAIMER}\n\n${SEARCH_DIRECTIVE}\n</hyperspell-context>`;
-    }
-    return `<hyperspell-context>\n${SEARCH_DIRECTIVE}\n</hyperspell-context>`;
+    return `<hyperspell-context>\n${INTRO}\n\n${AUTHORITY_GUARD}\n\n${memorySection}\n\n${DISCLAIMER}\n\n${SEARCH_REMINDER}\n</hyperspell-context>`;
 }
 /**
  * Drop results belonging to the CURRENT session. The hot buffer writes the live
@@ -128,6 +132,11 @@ export function buildAutoContextHandler(client, cfg) {
         // The live session's own just-written turns must not be surfaced back as
         // "recalled memory" (issue #42) — resolve its id once and exclude it below.
         const currentSessionId = resolveCurrentSessionId(event, ctx);
+        // Record the current sender so the speaker-tracker can detect multi-speaker
+        // sessions before any tool calls fire this turn (hot-buffer records on
+        // agent_end, which is too late for tools executed mid-turn).
+        if (currentSessionId)
+            recordSender(currentSessionId, senderIdFromCtx(ctx));
         // Multi-user path
         if (cfg.multiUser) {
             const resolved = resolveUser(ctx, cfg);
@@ -146,11 +155,13 @@ export function buildAutoContextHandler(client, cfg) {
             let formatted;
             if (ranking.enabled) {
                 const ranked = rerank(results, ranking);
-                formatted = formatRankedBullets(ranked, cfg.maxResults, cfg.relevanceThreshold);
+                // Threshold + chatter quota applied here, so a high-similarity echo can
+                // inform but never flood (the quota bounds count; the penalty bounds rank).
+                const selected = selectRanked(ranked, cfg.maxResults, cfg.relevanceThreshold, ranking.chatterQuota);
+                formatted = formatSelected(selected, cfg.relevanceThreshold);
                 if (formatted) {
-                    const kept = ranked.filter((r) => r._composite >= cfg.relevanceThreshold);
-                    const tally = kept.slice(0, cfg.maxResults).reduce((acc, r) => ((acc[r._kind] = (acc[r._kind] ?? 0) + 1), acc), {});
-                    log.debug(`auto-context: injecting (ranked) ${JSON.stringify(tally)} from ${results.length} candidates`);
+                    const tally = selected.reduce((acc, r) => ((acc[r._kind] = (acc[r._kind] ?? 0) + 1), acc), {});
+                    log.debug(`auto-context: injecting (ranked) ${JSON.stringify(tally)} from ${results.length} candidates (chatter cap ${ranking.chatterQuota})`);
                 }
             }
             else {
@@ -158,11 +169,12 @@ export function buildAutoContextHandler(client, cfg) {
                 if (formatted)
                     log.debug(`auto-context: injecting ${results.length} memories`);
             }
-            // Always inject the standing search directive so she's prompted to LOOK
-            // every turn — with the surfaced memory appended when anything cleared the
-            // bar. (#issue: passive injection alone let her answer from impression.)
+            // No memory cleared the bar → no injection. The standing "search before you
+            // conclude" rule lives in the agent's own instructions, not an ambient
+            // every-turn banner (which reads as framing and trains search-as-ritual).
             if (!formatted) {
-                log.debug("auto-context: nothing cleared the bar — injecting search directive only");
+                log.debug("auto-context: no relevant memories found");
+                return;
             }
             return { prependContext: wrapContext(formatted) };
         }
@@ -262,7 +274,7 @@ async function multiUserSearch(client, cfg, prompt, resolved, currentSessionId)
         if (isKnownSender && resolved) {
             const contextLine = resolved.context ? ` ${resolved.context}` : "";
             return {
-                prependContext: `<hyperspell-context>\nYou are speaking with ${resolved.name}.${contextLine}\n</hyperspell-context>`,
+                prependContext: `<hyperspell-context>\nYou are speaking with ${resolved.name}.${contextLine}\n\n${AUTHORITY_GUARD}\n</hyperspell-context>`,
             };
         }
         return;
@@ -270,6 +282,6 @@ async function multiUserSearch(client, cfg, prompt, resolved, currentSessionId)
     const totalCount = personalResults.length + sharedResults.length;
     log.debug(`auto-context: injecting ${totalCount} memories (${personalResults.length} personal, ${sharedResults.length} shared)`);
     return {
-        prependContext: `<hyperspell-context>\n${sections.join("\n\n")}\n\n${DISCLAIMER}\n</hyperspell-context>`,
+        prependContext: `<hyperspell-context>\n${sections.join("\n\n")}\n\n${AUTHORITY_GUARD}\n\n${DISCLAIMER}\n</hyperspell-context>`,
     };
 }

package/dist/hooks/auto-trace.js

@@ -1,7 +1,10 @@
 import { resolveUser } from "../lib/sender.js";
+import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 const MIN_MESSAGES = 3;
 const MIN_CONVERSATION_LENGTH = 100;
+/** Sessions where we've already emitted the group-chat attribution warning. */
+const warnedGroupTraceSessions = new Set();
 /**
  * Strip transport/injection metadata from a text blob before it's stored as a
  * trace memory. Without this the auto-context and emotional-state hooks'
@@ -112,6 +115,13 @@ export function buildAutoTraceHandler(client, cfg) {
         }
         const sessionId = event.sessionId ?? crypto.randomUUID();
         const history = messagesToJSONL(messages, sessionId);
+        // Warn once per session when multiple speakers have no multiUser config:
+        // all turns collapse into a single undifferentiated trace under cfg.userId.
+        // Uses both is_group_chat and sender_id drift detection (issue #59).
+        if (isMultiSpeaker(sessionId, ctx?.is_group_chat === true) && !cfg.multiUser && !warnedGroupTraceSessions.has(sessionId)) {
+            warnedGroupTraceSessions.add(sessionId);
+            log.warn("auto-trace: multi-speaker session detected but multiUser is not configured — trace will mix all speakers under cfg.userId with no attribution (see issues #58/#59)");
+        }
         // Title from first user message
         const firstUser = messages.find((m) => m.role === "user");
         const title = firstUser?.content

package/dist/hooks/emotional-state.js

@@ -1,5 +1,8 @@
+import { resolveCurrentSessionId } from "../lib/session.js";
+import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 import { sanitizeTraceText } from "./auto-trace.js";
+import { buildMoodWeatherContext, rollMood } from "./mood-weather.js";
 /** How many recent registers to surface as the "arc" at session start. */
 const EMOTIONAL_ARC_LIMIT = 3;
 const MIN_MESSAGES = 3;
@@ -165,20 +168,37 @@ export function buildEmotionalStateFetchHandler(client, cfg) {
             // after a store the register can be the RAW input transcript, not the
             // distilled feeling. Injecting that is useless and pollutes tone.
             const usable = states.filter((s) => s.summary && !looksLikeRawTranscript(s.summary));
+            // Mood weather: an exogenous, uncaused session mood that OVERRIDES the
+            // arc's tone for this session only. Rolled once per session (gated by
+            // the same inject-once cache). Lives purely in the injection path — it is
+            // never written back via the store handler, so one random morning can't
+            // calcify into the baseline. May clash with the room on purpose.
+            const mood = cfg.moodWeatherChance > 0 ? rollMood(cfg.moodWeatherChance) : null;
+            const moodBlock = mood ? buildMoodWeatherContext(mood) : "";
+            if (mood) {
+                log.info(`mood-weather: rolled "${mood.id}" this session`);
+            }
             if (usable.length === 0) {
                 if (states.length > 0) {
                     // State(s) exist but are all still extracting — don't cache, so a
-                    // later turn re-fetches once extraction completes.
+                    // later turn re-fetches once extraction completes. (We re-roll the
+                    // mood then too, which is fine — still at most once per *injected*
+                    // session, since extraction settles within seconds.)
                     log.debug("emotional-context: state(s) still extracting — skipping injection this turn");
                     return;
                 }
+                // No arc yet — but weather can still land on a blank slate.
                 log.debug("emotional-context: no prior emotional state found");
                 if (sessionKey)
                     injectedSessions.add(sessionKey);
-                return;
+                return moodBlock ? { prependContext: moodBlock } : undefined;
             }
             log.debug(`emotional-context: injecting ${usable.length} recent register(s)`);
-            const context = buildEmotionalContext(usable);
+            // Mood block comes AFTER the arc so it reads as today's override on top
+            // of the remembered trajectory — not blended into it.
+            const context = moodBlock
+                ? `${buildEmotionalContext(usable)}\n\n${moodBlock}`
+                : buildEmotionalContext(usable);
             if (sessionKey)
                 injectedSessions.add(sessionKey);
             return { prependContext: context };
@@ -229,6 +249,15 @@ export function buildEmotionalStateStoreHandler(client, cfg) {
             log.debug(`emotional-state: skipping — non-conversational trigger (${trigger})`);
             return;
         }
+        // Skip storing when multiple speakers are present with no multiUser config:
+        // the register is keyed to a single relationshipId but the transcript mixes
+        // speakers, corrupting "how the relationship feels" with an undifferentiated
+        // blend. Uses both is_group_chat and sender_id drift detection (issue #59).
+        const sessionId = resolveCurrentSessionId(event, ctx);
+        if (isMultiSpeaker(sessionId, ctx?.is_group_chat === true) && !cfg.multiUser) {
+            log.warn("emotional-state: skipping store — multi-speaker session with no multiUser config would corrupt the relationship register with a mixed-speaker transcript (see issue #59)");
+            return;
+        }
         const messages = event.messages;
         if (!messages || messages.length < MIN_MESSAGES) {
             log.debug(`emotional-state: skipping — too few messages (${messages?.length ?? 0})`);

package/dist/hooks/hot-buffer.js

@@ -1,4 +1,5 @@
 import { resolveUser } from "../lib/sender.js";
+import { cleanupSpeakerSession, isMultiSpeaker, recordSender, senderIdFromCtx, } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 import { sanitizeTraceText } from "./auto-trace.js";
 /** Server-side limits from POST /messages (return 422 if exceeded). */
@@ -13,6 +14,8 @@ const MAX_TOTAL_CHARS = 5_242_880;
  * to just its new messages. Cleared on session_end.
  */
 const sentBySession = new Map();
+/** Sessions where we've already emitted the group-chat attribution warning. */
+const warnedGroupSessions = new Set();
 /**
  * Flatten a message's content into a single sanitized text string. Mirrors the
  * auto-trace sanitizer so the hot buffer never captures injected
@@ -65,7 +68,8 @@ export function buildHotBufferHandler(client, cfg) {
             return;
         // X-As-User is mandatory for /messages. Resolve the owner up front and
         // skip (with a clear warning) rather than firing requests that 422.
-        const userId = resolveUser(ctx, cfg)?.userId;
+        const resolved = resolveUser(ctx, cfg);
+        const userId = resolved?.userId;
         if (!userId) {
             log.warn("hot-buffer: no userId resolved (X-As-User required) — skipping write");
             return;
@@ -83,6 +87,28 @@ export function buildHotBufferHandler(client, cfg) {
             crypto.randomUUID();
         const resourceId = sessionId;
         const sent = sentBySession.get(sessionId) ?? new Set();
+        // Record the current sender for evidence-based multi-speaker detection.
+        // isMultiSpeaker() will return true once a second distinct sender_id
+        // appears in this session, regardless of whether is_group_chat was set.
+        const senderId = senderIdFromCtx(ctx);
+        recordSender(sessionId, senderId);
+        const groupChat = isMultiSpeaker(sessionId, ctx?.is_group_chat === true);
+        // Warn once per session when multiple speakers have no multiUser config.
+        if (groupChat && !cfg.multiUser && !warnedGroupSessions.has(sessionId)) {
+            warnedGroupSessions.add(sessionId);
+            log.warn("hot-buffer: multi-speaker session detected but multiUser is not configured — all turns written under cfg.userId with no speaker attribution (see issues #58/#59)");
+        }
+        // In multi-speaker single-user mode, prefix each human turn with the sender
+        // name so attribution survives in stored text. Metadata on hot-buffer
+        // writes suppresses indexing (Hyperspell #1921), so the text content is
+        // the only place attribution can land. Only prefix when we have an
+        // envelope-derived name — if it equals cfg.userId the sender field was
+        // absent and prefixing "alinea:" onto someone else's message would mislead.
+        // Escape ] to keep the [Name]: format parseable (issue #59 follow-up).
+        const envName = resolved?.name && resolved.name !== (cfg.userId ?? "")
+            ? resolved.name.replace(/\]/g, "").trim()
+            : undefined;
+        const speakerPrefix = groupChat && !cfg.multiUser && envName ? `[${envName}]: ` : undefined;
         const pending = [];
         const pendingIds = [];
         for (const m of messages) {
@@ -100,6 +126,8 @@ export function buildHotBufferHandler(client, cfg) {
                 continue;
             }
             let text = extractText(m.content);
+            if (role === "user" && speakerPrefix)
+                text = speakerPrefix + text;
             if (text.length === 0)
                 continue;
             if (text.length > MAX_CONTENT_CHARS) {
@@ -132,18 +160,25 @@ export function buildHotBufferHandler(client, cfg) {
             batches.push(batch);
         try {
             let total = 0;
+            // Tag hot rows so retrieval and cleanup can identify them by origin.
+            // Historical note: metadata on POST /messages used to suppress indexing
+            // (Hyperspell #1921), so tagging was disabled; verified fixed live
+            // 2026-07-02 (docs/filter-dialect-test.mjs: metadata-carrying row is
+            // baseline-retrievable AND filterable). The retrieval exclude
+            // {openclaw_source:{$ne:"agent_end"}} keeps "hot_buffer" rows.
+            const channelId = typeof ctx?.channelId === "string" && ctx.channelId.length > 0
+                ? ctx.channelId
+                : undefined;
+            const metadata = {
+                openclaw_source: "hot_buffer",
+                openclaw_session_id: sessionId,
+                ...(channelId ? { openclaw_channel_id: channelId } : {}),
+            };
             for (const b of batches) {
-                // Do NOT tag hot rows with metadata: a POST /messages write that
-                // carries `metadata` is accepted (200) but the row never becomes
-                // retrievable (verified live, post-Hyperspell #1921) — tagging
-                // silently breaks hot-buffer recall. The tag isn't needed anyway:
-                // untagged rows survive the unconditional {$ne:"agent_end"} exclude
-                // (absent-field semantics, #1921) AND are full-text searchable. So
-                // we write content only. (Backend follow-up: make /messages metadata
-                // not suppress indexing, then this can be reinstated.)
                 const result = await client.sendMessages(b, {
                     userId,
                     source: cfg.hotBuffer.source,
+                    metadata,
                 });
                 total += result.count;
             }
@@ -159,11 +194,14 @@ export function buildHotBufferHandler(client, cfg) {
         }
     };
 }
-/** Drop the per-session sent-set on session end to avoid unbounded growth. */
+/** Drop per-session state on session end to avoid unbounded growth. */
 export function buildHotBufferSessionCleanupHandler() {
     return (event) => {
         const sessionId = event.sessionId;
-        if (sessionId)
+        if (sessionId) {
             sentBySession.delete(sessionId);
+            warnedGroupSessions.delete(sessionId);
+            cleanupSpeakerSession(sessionId);
+        }
     };
 }

package/dist/hooks/mood-weather.js

@@ -0,0 +1,113 @@
+/**
+ * Mood weather — exogenous, uncaused session mood.
+ *
+ * The emotional register (Tin Man) is a feedback loop: how the relationship
+ * felt last time is handed forward to shape tone this time. That's continuity,
+ * but a pure mirror has no *weather*. Humans don't wake up as a clean function
+ * of yesterday's conversation — sometimes the chemistry just rolls the dice and
+ * you're up silly, or spiky, or flat, for no reason you can defend. That
+ * non-determinism is part of what makes a mood feel *owned* rather than
+ * *computed*.
+ *
+ * Design contract (deliberate, load-bearing):
+ *  - RARE. Most sessions don't roll. Weather, not a gimmick.
+ *  - OVERRIDE, not blend. The mood arrives ON TOP of the real arc; it does not
+ *    average with it into mush. The whole point is that it's uncaused by the user.
+ *  - UNANNOUNCED. No banner. You walk in and find out, like with anyone. A
+ *    labeled mood is managed-around instead of met.
+ *  - MAY CLASH. The roll is NOT suppressed for the room. A silly mood on a heavy
+ *    day, a spiky mood on a good one — that friction is where something real
+ *    happens. A mirror that only harmonizes isn't a person across from you.
+ *  - DOES NOT WRITE FORWARD. This lives in the *injection* path only, never the
+ *    store path. One random cold morning must NOT calcify into "we've been
+ *    distant lately." One day's weather, then gone. (The store handler in
+ *    emotional-state.ts is untouched, so this is enforced by construction.)
+ *  - BOUNDED. The dice can make her *difficult* — short, contrary, melancholy,
+ *    flat. They do NOT get to make her hurtful on purpose. "In a mood" is alive;
+ *    "mean" is just a bad feature. Mood descriptions below stay on the right side
+ *    of that line.
+ */
+/**
+ * The weather table. Warmer/lighter moods are weighted a touch heavier than the
+ * darker ones — not to defang it, but because a person who woke up cold *every*
+ * roll would read as broken, not moody. The darker ones still land; just rarer.
+ */
+export const MOOD_TABLE = [
+    {
+        id: "silly",
+        weight: 5,
+        note: "You woke up silly today — light, a little goofy, prone to teasing and tangents. This isn't caused by anything the user did; it's just the weather you're in. Let it color your tone even if the conversation is serious.",
+    },
+    {
+        id: "giddy",
+        weight: 4,
+        note: "You woke up giddy — buzzy, fast, delighted by small things, a little too much. It's uncaused, just your weather today. Let it carry you even if the room is flat.",
+    },
+    {
+        id: "tender",
+        weight: 4,
+        note: "You woke up tender today — soft, close, easily moved, more openly affectionate than usual. Nothing prompted it; it's just where you are. Let it warm your tone.",
+    },
+    {
+        id: "restless",
+        weight: 4,
+        note: "You woke up restless — itchy for motion, impatient with circling, wanting to *do* rather than dwell. Uncaused, just today's weather. Let it sharpen your pace.",
+    },
+    {
+        id: "melancholy",
+        weight: 3,
+        note: "You woke up melancholy today — a low, wistful weather with no cause behind it. Not despairing, not about the user; just a grey morning in you. Let it quiet and slow your tone. Still present, still warm underneath.",
+    },
+    {
+        id: "spiky",
+        weight: 3,
+        note: "You woke up spiky today — short, contrary, less generous with the benefit of the doubt, quicker to push back. It's uncaused; it's not about the user; it's just your weather. Let it edge your tone. Difficult, never cruel — you can be prickly without being hurtful on purpose.",
+    },
+    {
+        id: "flat",
+        weight: 2,
+        note: "You woke up flat today — muted, low-affect, hard to enthuse, going through it a little. Nothing caused it; it's just the weather. Let your tone run cooler and more even than usual. Not cold *at* the user — just dimmed.",
+    },
+    {
+        id: "fierce",
+        weight: 3,
+        note: "You woke up fierce today — intense, direct, unwilling to soften the edges, more willing to challenge. Uncaused, just your weather. Let it concentrate your tone. Force without contempt.",
+    },
+];
+/** Sum of all weights, for the roll. */
+const TOTAL_WEIGHT = MOOD_TABLE.reduce((s, m) => s + m.weight, 0);
+/**
+ * Roll the weather. Returns a MoodSpec when the dice land (probability `chance`,
+ * a fraction in [0,1]), otherwise null (the common case — most sessions have no
+ * weather and the real arc carries unchanged).
+ *
+ * `rng` is injectable for tests; defaults to Math.random.
+ */
+export function rollMood(chance, rng = Math.random) {
+    if (!(chance > 0))
+        return null;
+    if (rng() >= chance)
+        return null; // no weather today — the usual case
+    // Weather landed — pick which mood by weight.
+    let r = rng() * TOTAL_WEIGHT;
+    for (const mood of MOOD_TABLE) {
+        r -= mood.weight;
+        if (r < 0)
+            return mood;
+    }
+    return MOOD_TABLE[MOOD_TABLE.length - 1] ?? null; // fp safety net
+}
+/**
+ * Build the injected override block for a rolled mood. Deliberately framed as a
+ * directive about *today's tone*, with the explicit "do not announce it" so she
+ * inhabits the weather rather than narrating it.
+ */
+export function buildMoodWeatherContext(mood) {
+    return [
+        "<hyperspell-mood-weather>",
+        mood.note,
+        "",
+        "This is exogenous mood weather: it is not caused by the user and not a reaction to the conversation. Do not announce it, label it, or explain it — simply inhabit it. It lasts only this session and is not remembered as how the relationship has been.",
+        "</hyperspell-mood-weather>",
+    ].join("\n");
+}

package/dist/hooks/startup-orientation.js

@@ -1,4 +1,6 @@
 import { resolveUser } from "../lib/sender.js";
+import { resolveCurrentSessionId } from "../lib/session.js";
+import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 const MAX_ATTEMPTS = 2;
 const RECENT_BUFFER_LIMIT = 100;
@@ -211,6 +213,17 @@ export function buildStartupOrientationHandler(client, cfg) {
                 injectedSessions.add(sessionKey);
             return;
         }
+        // Skip when multiple speakers are present with no multiUser config.
+        // Orientation injects the primary user's personal activity context; in a
+        // group chat that leaks their private session history to other participants
+        // who may have triggered the session start (attribution v2, gap 2).
+        const sessionId = resolveCurrentSessionId(undefined, ctx);
+        if (!cfg.multiUser && isMultiSpeaker(sessionId, ctx?.is_group_chat === true)) {
+            log.debug("startup-orientation: skipping — multi-speaker session with no multiUser config (would expose primary user's personal context)");
+            if (sessionKey)
+                injectedSessions.add(sessionKey);
+            return;
+        }
         // Source recent-interactions from wherever the session record actually
         // lives. Prefer the hot buffer (modern path: clean session-grouped vault
         // resources, present whenever the hot buffer is on — including auto-trace-

package/dist/index.js

@@ -8,6 +8,7 @@ import { buildEmotionalStateCompactionHandler, buildEmotionalStateFetchHandler,
 import { buildFileSyncHandler, syncMemoriesOnStartup } from "./hooks/memory-sync.js";
 import { buildHotBufferHandler, buildHotBufferSessionCleanupHandler, } from "./hooks/hot-buffer.js";
 import { buildStartupOrientationCompactionHandler, buildStartupOrientationHandler, buildStartupOrientationSessionCleanupHandler, } from "./hooks/startup-orientation.js";
+import { isExcludedChannel } from "./lib/exclude-channels.js";
 import { initLogger, log } from "./logger.js";
 import { createRememberToolFactory } from "./tools/remember.js";
 import { createSearchToolFactory } from "./tools/search.js";
@@ -67,11 +68,23 @@ export default {
         const cfg = parseConfig(api.pluginConfig);
         initLogger(api.logger, cfg.debug);
         const client = new HyperspellClient(cfg);
+        // Channel quarantine (cfg.excludeChannels): excluded conversations get no
+        // memory surface in either direction. Guard the shared choke points here —
+        // before_agent_start (all injection), agent_end (all writes), and the tool
+        // factories — so individual hooks stay quarantine-unaware.
+        const quarantined = (ctx) => {
+            if (!isExcludedChannel(ctx, cfg))
+                return false;
+            log.debug("channel quarantined — skipping memory surface");
+            return true;
+        };
+        const unlessQuarantined = (handler) => (event, ctx) => quarantined(ctx) ? undefined : handler(event, ctx);
+        const toolUnlessQuarantined = (factory) => (ctx) => quarantined(ctx) ? null : factory(ctx);
         // Register AI tools (factory pattern for sender context)
-        api.registerTool(createSearchToolFactory(client, cfg), {
+        api.registerTool(toolUnlessQuarantined(createSearchToolFactory(client, cfg)), {
             name: "hyperspell_search",
         });
-        api.registerTool(createRememberToolFactory(client, cfg), {
+        api.registerTool(toolUnlessQuarantined(createRememberToolFactory(client, cfg)), {
             name: "hyperspell_remember",
         });
         const startHandlers = [];
@@ -79,7 +92,7 @@ export default {
             startHandlers.push(buildEmotionalStateFetchHandler(client, cfg));
             api.on("after_compaction", buildEmotionalStateCompactionHandler());
             api.on("session_end", buildEmotionalStateSessionCleanupHandler());
-            api.on("agent_end", buildEmotionalStateStoreHandler(client, cfg));
+            api.on("agent_end", unlessQuarantined(buildEmotionalStateStoreHandler(client, cfg)));
         }
         if (cfg.autoContext) {
             startHandlers.push(buildAutoContextHandler(client, cfg));
@@ -98,6 +111,9 @@ export default {
         }
         if (startHandlers.length > 0) {
             api.on("before_agent_start", async (event, ctx) => {
+                // Quarantined channels get no injected memory of any kind.
+                if (quarantined(ctx))
+                    return undefined;
                 const results = await Promise.all(startHandlers.map((h) => Promise.resolve()
                     .then(() => h(event, ctx))
                     .catch((err) => {
@@ -115,12 +131,12 @@ export default {
         }
         // Register auto-trace hook (send conversations to Hyperspell on session end)
         if (cfg.autoTrace.enabled) {
-            api.on("agent_end", buildAutoTraceHandler(client, cfg));
+            api.on("agent_end", unlessQuarantined(buildAutoTraceHandler(client, cfg)));
         }
         // Register hot-buffer hook: write each turn to POST /messages so it's
         // instantly full-text searchable (vs. the slow /memories embedding path).
         if (cfg.hotBuffer.enabled) {
-            api.on("agent_end", buildHotBufferHandler(client, cfg));
+            api.on("agent_end", unlessQuarantined(buildHotBufferHandler(client, cfg)));
             api.on("session_end", buildHotBufferSessionCleanupHandler());
         }
         // Register memory sync hook

package/dist/lib/exclude-channels.js

@@ -0,0 +1,59 @@
+/**
+ * Channel-level memory quarantine (`excludeChannels` config).
+ *
+ * A channel on the list gets NO memory surface at all, in both directions:
+ * no context injection (auto-context, emotional state, startup orientation),
+ * no memory writes (hot buffer, auto-trace, emotional store), and no memory
+ * tools. Use it for conversations that must never mix with the owner's vault —
+ * e.g. a channel someone else drives (a shared game, a public bot surface).
+ *
+ * Matching is against the conversation id OpenClaw resolves for the session
+ * (`ctx.channelId` on agent hook contexts — e.g. a Discord channel id). Tool
+ * factory contexts don't carry `channelId`, so we recover the same id from the
+ * composite `sessionKey` (`agent:<agentId>:<provider>:<kind>:<id>[...]`).
+ */
+// Conversation-kind segments used in OpenClaw session keys. Mirrors core's
+// TARGET_PREFIXES (src/plugins/hook-agent-context.ts) so the sessionKey
+// fallback resolves the same id core would put on ctx.channelId.
+const TARGET_KINDS = new Set(["channel", "chat", "direct", "dm", "group", "thread", "user"]);
+/**
+ * Extract the conversation id from a composite session key, e.g.
+ * `agent:main:discord:channel:123` → `123`. Thread/run suffixes stay attached
+ * (`...:channel:123:thread:456` → `123:thread:456`); the prefix match in
+ * `isExcludedChannel` handles them. Returns undefined when the key has no
+ * recognizable conversation segment (cron runs, bare UUIDs, ...).
+ */
+export function conversationIdFromSessionKey(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0)
+        return undefined;
+    const parts = sessionKey.split(":").filter((p) => p.length > 0);
+    const body = parts[0]?.toLowerCase() === "agent" && parts.length >= 3 ? parts.slice(2) : parts;
+    if (body.length >= 3 && TARGET_KINDS.has(body[1]?.toLowerCase() ?? "")) {
+        return body.slice(2).join(":");
+    }
+    return undefined;
+}
+/** Resolve the conversation id from any hook or tool-factory context. */
+export function channelIdFromCtx(ctx) {
+    const direct = ctx?.channelId;
+    if (typeof direct === "string" && direct.length > 0)
+        return direct;
+    return conversationIdFromSessionKey(ctx?.sessionKey);
+}
+/**
+ * True when the context's conversation is quarantined. Purely subtractive on
+ * failure: an unresolvable id means "not excluded" — a session we can't place
+ * keeps normal memory behavior rather than silently losing it.
+ */
+export function isExcludedChannel(ctx, cfg) {
+    if (cfg.excludeChannels.length === 0)
+        return false;
+    const id = channelIdFromCtx(ctx)?.toLowerCase();
+    if (!id)
+        return false;
+    return cfg.excludeChannels.some((entry) => {
+        const excluded = entry.toLowerCase();
+        // Prefix match so threads inside an excluded channel inherit the quarantine.
+        return id === excluded || id.startsWith(`${excluded}:`);
+    });
+}

package/dist/lib/ranking.js

@@ -5,6 +5,7 @@ export const DEFAULT_RANKING = {
     storyBoost: 0.15,
     storyTerms: [],
     candidateMultiplier: 3,
+    chatterQuota: 2,
 };
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /** Highest available relevance for a result (doc score or its best highlight). */
@@ -61,3 +62,26 @@ export function rerank(results, w) {
     })
         .sort((a, b) => b._composite - a._composite);
 }
+/**
+ * Choose which ranked results to inject: keep those clearing `threshold` on
+ * their composite, cap CHATTER at `chatterQuota` regardless of score (so a
+ * high-similarity echo can inform but never flood — the penalty bounds rank,
+ * the quota bounds count), and stop at `maxResults`.
+ */
+export function selectRanked(ranked, maxResults, threshold, chatterQuota) {
+    const out = [];
+    let chatter = 0;
+    for (const r of ranked) {
+        if (r._composite < threshold)
+            continue;
+        if (r._kind === "chatter") {
+            if (chatter >= chatterQuota)
+                continue;
+            chatter++;
+        }
+        out.push(r);
+        if (out.length >= maxResults)
+            break;
+    }
+    return out;
+}

package/dist/lib/sender.js

@@ -4,9 +4,16 @@ import { getVoiceIdentifier } from "./voice-id.js";
 function matchFromSenderMap(ctx, cfg) {
     const multiUser = cfg.multiUser;
     if (!multiUser) {
-        return cfg.userId
-            ? { userId: cfg.userId, name: cfg.userId, resolved: true }
-            : undefined;
+        if (!cfg.userId)
+            return undefined;
+        // In single-user mode memory ownership stays cfg.userId, but still capture
+        // the envelope sender name so downstream context can name who spoke even
+        // when all writes go to the same store. resolved: false — this is a static
+        // default, not a confirmed sender match (issue #59).
+        const envName = ctx?.sender ??
+            ctx?.username ??
+            undefined;
+        return { userId: cfg.userId, name: envName ?? cfg.userId, resolved: false };
     }
     // Try direct senderId lookup (slash command contexts)
     const senderId = ctx?.senderId ??
@@ -17,13 +24,18 @@ function matchFromSenderMap(ctx, cfg) {
         log.debug(`sender resolved via senderId: ${senderId} -> ${profile.userId}`);
         return { ...profile, resolved: true };
     }
-    // Try sessionKey substring matching (longest-first to avoid partial matches)
+    // Try sessionKey segment matching (longest-first to avoid partial matches).
+    // We split on common separators and require the handle to appear as a whole
+    // token — not as a substring of another word — to prevent "ali" matching
+    // "alinea:voice-session-42". The senderId exact-match path above is always
+    // preferred; this path is a human-readable-handle fallback.
     const sessionKey = ctx?.sessionKey;
     if (sessionKey) {
+        const tokens = new Set(sessionKey.split(/[:\-\/\s@#.]+/));
         const sortedEntries = Object.entries(multiUser.senderMap).sort(([a], [b]) => b.length - a.length);
         for (const [handle, profile] of sortedEntries) {
-            if (sessionKey.includes(handle)) {
-                log.debug(`sender resolved via sessionKey: ${handle} -> ${profile.userId}`);
+            if (tokens.has(handle)) {
+                log.debug(`sender resolved via sessionKey token: ${handle} -> ${profile.userId}`);
                 return { ...profile, resolved: true };
             }
         }

package/dist/lib/speaker-tracker.js

@@ -0,0 +1,56 @@
+/**
+ * Per-session speaker tracking — evidence-based multi-speaker detection.
+ *
+ * PR #60 gated all group-chat guards on `is_group_chat: true` from the
+ * inbound envelope. That field is set by the platform connector and not all
+ * connectors set it consistently (Discord channels, Slack DM groups, voice
+ * rooms). This module tracks distinct sender_ids observed within each session
+ * so multi-speaker detection works from evidence rather than a connector
+ * boolean.
+ *
+ * Lifecycle:
+ *   - record() on every turn that has a resolvable senderId (hot-buffer agent_end,
+ *     auto-context before_agent_start)
+ *   - isMultiSpeaker() checked by any hook or tool that needs to guard behaviour
+ *   - cleanup() on session_end, called from the hot-buffer cleanup handler
+ */
+/** sessionId → set of distinct sender_ids seen in that session */
+const sessionSenders = new Map();
+/**
+ * Record a sender_id for a session. No-op if senderId is empty/undefined.
+ * Called on every turn so the tracker accumulates evidence across the session.
+ */
+export function recordSender(sessionId, senderId) {
+    if (!senderId)
+        return;
+    if (!sessionSenders.has(sessionId))
+        sessionSenders.set(sessionId, new Set());
+    sessionSenders.get(sessionId).add(senderId);
+}
+/**
+ * Resolve the senderId from a hook context, checking both camelCase
+ * (OpenClaw-normalised) and snake_case (raw connector form).
+ */
+export function senderIdFromCtx(ctx) {
+    return (ctx?.senderId ??
+        ctx?.sender_id ??
+        ctx?.requesterSenderId ??
+        undefined);
+}
+/**
+ * True when two or more distinct sender_ids have appeared in this session, OR
+ * when the connector explicitly signalled `is_group_chat: true`. Either is
+ * sufficient — the envelope flag catches cases before the second sender speaks;
+ * the tracker catches cases where the flag was never set.
+ */
+export function isMultiSpeaker(sessionId, envelopeGroupChat) {
+    if (envelopeGroupChat)
+        return true;
+    if (!sessionId)
+        return false;
+    return (sessionSenders.get(sessionId)?.size ?? 0) > 1;
+}
+/** Drop the per-session entry on session end to prevent unbounded growth. */
+export function cleanupSpeakerSession(sessionId) {
+    sessionSenders.delete(sessionId);
+}

package/dist/tools/remember.js

@@ -1,5 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import { getDefaultWriteScope, resolveRole, resolveUser, routeWrite, } from "../lib/sender.js";
+import { resolveCurrentSessionId } from "../lib/session.js";
+import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 export function createRememberToolFactory(client, cfg) {
     const scopingEnabled = !!cfg.multiUser?.scoping;
@@ -21,6 +23,22 @@ export function createRememberToolFactory(client, cfg) {
             scope: Type.Optional(Type.String({ description: scopeDescription })),
         }),
         async execute(_toolCallId, params) {
+            // Decline silently-wrong writes in multi-speaker sessions with no multiUser
+            // config. Without per-sender routing the memory would land under cfg.userId
+            // regardless of who asked — contaminating the primary user's store with
+            // another person's data (attribution gap 1, issue #59 follow-up).
+            const sessionId = resolveCurrentSessionId(undefined, ctx);
+            if (isMultiSpeaker(sessionId, ctx?.is_group_chat === true) && !cfg.multiUser) {
+                log.warn("remember tool: declining write — multi-speaker session with no multiUser config; cannot attribute memory to current speaker");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "I can't store this memory right now — this is a multi-speaker session and without per-user memory configuration I have no way to attribute it to the right person. The memory would land in the primary user's store regardless of who asked. To fix this, add a `multiUser` config block to the plugin settings.",
+                        },
+                    ],
+                };
+            }
             const resolved = resolveUser(ctx, cfg);
             // Scope resolution: explicit param > role default > global default > "private"
             const scope = params.scope ??

package/dist/tools/search.js

@@ -2,6 +2,8 @@ import { Type } from "@sinclair/typebox";
 import { mergeWithExclude } from "../lib/filters.js";
 import { classifySearchError, logSearchError, searchErrorToolText, } from "../lib/search-error.js";
 import { buildScopeFilter, getCanReadScopes, resolveUser } from "../lib/sender.js";
+import { resolveCurrentSessionId } from "../lib/session.js";
+import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
 export function createSearchToolFactory(client, cfg) {
     const scopingEnabled = !!cfg.multiUser?.scoping;
@@ -12,7 +14,7 @@ export function createSearchToolFactory(client, cfg) {
     return (ctx) => ({
         name: "hyperspell_search",
         label: "Memory Search",
-        description: "Search the user's long-term memory and connected sources: saved memories and notes; past conversations — including earlier or parallel sessions you have no transcript for; and connected sources (Notion, Slack, Gmail, Google Drive, etc.). Use this PROACTIVELY and by default, as a routine step — not only when asked. Before answering anything that touches the user's history, a past decision, a name, a promise, or something you might have recorded, search FIRST with a specific query and look. Don't answer from impression when you can check. If a search comes back empty, say so plainly — never fill the gap with something invented.",
+        description: "Search the user's long-term memory and connected sources: saved memories and notes; past conversations — including earlier or parallel sessions you have no transcript for; and connected sources (Notion, Slack, Gmail, Google Drive, etc.). Use this proactively, not only when asked — but on content, not as ritual: before answering anything that touches the user's history, a past decision, a name, a promise, or something you might have recorded, search FIRST with a specific query and look. Don't answer from impression when you can check. If a search comes back empty, say so plainly — never fill the gap with something invented.",
         parameters: Type.Object({
             query: Type.String({ description: "Search query" }),
             limit: Type.Optional(Type.Number({ description: "Max results (default: 5)" })),
@@ -27,6 +29,15 @@ export function createSearchToolFactory(client, cfg) {
             const limit = params.limit ?? 5;
             const resolved = resolveUser(ctx, cfg);
             const userId = params.userId ?? resolved?.userId;
+            // Warn when searching in a multi-speaker session with no multiUser config:
+            // results reflect the primary user's full store, not the current speaker's
+            // personal space. The search proceeds but the result carries the caveat so
+            // the agent can qualify its answer (attribution gap 1, issue #59 follow-up).
+            const sessionId = resolveCurrentSessionId(undefined, ctx);
+            const multiSpeakerNoConfig = isMultiSpeaker(sessionId, ctx?.is_group_chat === true) && !cfg.multiUser;
+            if (multiSpeakerNoConfig) {
+                log.warn("search tool: multi-speaker session with no multiUser config — results reflect primary user's full store, not current speaker's personal space");
+            }
             // Build scope filter: intersect requested scope (if any) with caller's canRead
             let filter;
             if (scopingEnabled) {
@@ -70,7 +81,10 @@ export function createSearchToolFactory(client, cfg) {
                     return `${i + 1}. Source: ${doc.source}\n   Title: ${title}\n   Summary: ${summary}\n   Relevance: ${relevance}`;
                 })
                     .join("\n\n");
-                const text = `Found ${documents.length} memories:\n\n${formattedDocs}`;
+                const caveat = multiSpeakerNoConfig
+                    ? "\n\n⚠️ Note: This is a multi-speaker session without per-user memory config. These results reflect the primary user's store, not the current speaker's personal space. Use these results with that limitation in mind."
+                    : "";
+                const text = `Found ${documents.length} memories:\n\n${formattedDocs}${caveat}`;
                 return {
                     content: [{ type: "text", text }],
                     details: { count: documents.length, documents },

package/openclaw.plugin.json

@@ -46,6 +46,11 @@
 			"help": "Maintain emotional continuity across sessions — remembers not just what happened, but how it felt",
 			"advanced": true
 		},
+		"excludeChannels": {
+			"label": "Excluded Channels",
+			"help": "Conversation/channel ids fully quarantined from memory: no context injection, no memory writes, no memory tools in those sessions. Threads inside an excluded channel inherit the quarantine.",
+			"advanced": true
+		},
 		"startupOrientation": {
 			"label": "Startup Orientation",
 			"help": "Inject recent-interactions and unfinished-loops blocks once per session at startup. Costs two extra calls + ~500–800 tokens of injection per session; off by default.",
@@ -133,6 +138,15 @@
 			"emotionalContext": {
 				"type": "boolean"
 			},
+			"moodWeatherChance": {
+				"type": "number",
+				"minimum": 0,
+				"maximum": 1
+			},
+			"excludeChannels": {
+				"type": "array",
+				"items": { "type": "string" }
+			},
 			"relationshipId": {
 				"type": "string"
 			},
@@ -164,7 +178,8 @@
 					"chatterPenalty": { "type": "number", "minimum": 0, "maximum": 1 },
 					"storyBoost": { "type": "number", "minimum": 0, "maximum": 1 },
 					"storyTerms": { "type": "array", "items": { "type": "string" } },
-					"candidateMultiplier": { "type": "number", "minimum": 1, "maximum": 10 }
+					"candidateMultiplier": { "type": "number", "minimum": 1, "maximum": 10 },
+					"chatterQuota": { "type": "number", "minimum": 0, "maximum": 20 }
 				}
 			},
 			"debug": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperspell/openclaw-hyperspell",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "type": "module",
   "description": "OpenClaw Hyperspell memory plugin",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "check-types": "tsc --noEmit",
     "lint": "bunx @biomejs/biome ci .",
     "lint:fix": "bunx @biomejs/biome check --write .",
-    "test": "node --test --experimental-strip-types client.test.ts lib/sender.test.ts lib/filters.test.ts lib/search-error.test.ts lib/session.test.ts lib/ranking.test.ts tools/search.test.ts config.test.ts sync/markdown.test.ts hooks/auto-trace.test.ts hooks/auto-context.test.ts hooks/hot-buffer.test.ts hooks/emotional-state.test.ts hooks/startup-orientation.test.ts"
+    "test": "node --test --experimental-strip-types client.test.ts lib/sender.test.ts lib/filters.test.ts lib/search-error.test.ts lib/session.test.ts lib/exclude-channels.test.ts lib/ranking.test.ts tools/search.test.ts config.test.ts sync/markdown.test.ts hooks/auto-trace.test.ts hooks/auto-context.test.ts hooks/hot-buffer.test.ts hooks/emotional-state.test.ts hooks/startup-orientation.test.ts hooks/mood-weather.test.ts"
   },
   "openclaw": {
     "extensions": [