@hyperspell/openclaw-hyperspell 0.18.1 → 0.20.0

package/dist/commands/slash.js

@@ -1,7 +1,10 @@
 import { getWorkspaceDir } from "../config.js";
+import { MOOD_WEATHER_COLLECTION } from "../hooks/mood-weather.js";
+import { MOOD_WEATHER_SOURCE } from "../lib/filters.js";
 import { buildScopeFilter, getCanReadScopes, getDefaultWriteScope, resolveRole, resolveUser, routeWrite, } from "../lib/sender.js";
 import { log } from "../logger.js";
 import { syncAllMemoryFiles } from "../sync/markdown.js";
+import { buildPreviewReport } from "./preview.js";
 /**
  * Strip a `#scope-name` prefix from free text. Returns the scope and the
  * remainder. Used by /remember and /getcontext to let users narrow or route
@@ -156,4 +159,59 @@ export function registerCommands(api, client, cfg) {
             }
         },
     });
+    // /moodweather — private roll history (operator retrospection only; these rows
+    // are excluded from all agent recall, so this command is the ONLY reader).
+    api.registerCommand({
+        name: "moodweather",
+        description: "Show recent mood-weather rolls (never fed back into tone)",
+        acceptsArgs: false,
+        requireAuth: true,
+        handler: async () => {
+            log.debug("/moodweather command");
+            try {
+                const rows = [];
+                for await (const mem of client.listMemories({
+                    collection: MOOD_WEATHER_COLLECTION,
+                    pageSize: 50,
+                })) {
+                    if (mem.metadata?.openclaw_source !== MOOD_WEATHER_SOURCE)
+                        continue;
+                    rows.push({
+                        mood: String(mem.metadata.mood ?? "?"),
+                        rolledAt: String(mem.metadata.rolled_at ?? ""),
+                    });
+                    if (rows.length >= 20)
+                        break;
+                }
+                if (rows.length === 0) {
+                    return { text: "No mood-weather rolls recorded." };
+                }
+                const lines = rows.map((r) => `• ${r.rolledAt.slice(0, 16).replace("T", " ")} — ${r.mood}`);
+                return {
+                    text: `Recent mood-weather rolls (newest first):\n${lines.join("\n")}`,
+                };
+            }
+            catch (err) {
+                log.error("/moodweather failed", err);
+                return { text: "Failed to fetch mood-weather history. Check logs for details." };
+            }
+        },
+    });
+    // /previewcontext - Show what would be injected into the next session
+    api.registerCommand({
+        name: "previewcontext",
+        description: "Preview what Hyperspell would inject at the next session start",
+        acceptsArgs: false,
+        requireAuth: true,
+        handler: async (ctx) => {
+            log.debug("/previewcontext command");
+            try {
+                return { text: await buildPreviewReport(client, cfg, ctx) };
+            }
+            catch (err) {
+                log.error("/previewcontext failed", err);
+                return { text: "Failed to build preview. Check logs for details." };
+            }
+        },
+    });
 }

package/dist/config.js

@@ -62,6 +62,39 @@ function resolveEnvVars(value) {
         return envValue;
     });
 }
+/**
+ * Normalize `syncMemories.watchPaths` entries: the shipped/documented string
+ * form stays valid and is additive-upgraded to `{ path }`; the object form
+ * carries an optional provenance `source` label. Labels are sanitized with the
+ * same character rule as normalizeScope — metadata values must be alphanumeric
+ * + underscore or Hyperspell metadata filters silently miss.
+ */
+function parseWatchPaths(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((wp) => {
+        if (typeof wp === "string") {
+            if (!wp.trim()) {
+                throw new Error("hyperspell.syncMemories.watchPaths[] entry needs a non-empty path");
+            }
+            return { path: wp };
+        }
+        if (typeof wp !== "object" || wp === null || Array.isArray(wp)) {
+            throw new Error("hyperspell.syncMemories.watchPaths[] entries must be a string or { path, source? }");
+        }
+        const entry = wp;
+        assertAllowedKeys(entry, ["path", "source"], "hyperspell.syncMemories.watchPaths[]");
+        if (typeof entry.path !== "string" || !entry.path.trim()) {
+            throw new Error("hyperspell.syncMemories.watchPaths[] entry needs a non-empty path");
+        }
+        if (!entry.source)
+            return { path: entry.path };
+        return {
+            path: entry.path,
+            source: String(entry.source).replace(/[^a-zA-Z0-9_]/g, "_"),
+        };
+    });
+}
 function parseRanking(raw) {
     const r = (raw ?? {});
     const num = (v, d) => (typeof v === "number" ? v : d);
@@ -70,8 +103,16 @@ function parseRanking(raw) {
         curationBoost: num(r.curationBoost, DEFAULT_RANKING.curationBoost),
         chatterPenalty: num(r.chatterPenalty, DEFAULT_RANKING.chatterPenalty),
         storyBoost: num(r.storyBoost, DEFAULT_RANKING.storyBoost),
+        // Trim + lowercase + dedupe, drop whitespace-only entries. Before this a
+        // stray " " entry passed the length filter and (under the old substring
+        // matcher) classified EVERY result as story, silently disabling the
+        // chatter penalty and quota (issue #82's footgun).
         storyTerms: Array.isArray(r.storyTerms)
-            ? r.storyTerms.map((t) => String(t)).filter((t) => t.length > 0)
+            ? [
+                ...new Set(r.storyTerms
+                    .map((t) => String(t).trim().toLowerCase())
+                    .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)),
@@ -324,9 +365,7 @@ export function parseConfig(raw) {
         syncMemoriesConfig: {
             enabled: syncMemoriesEnabled,
             sectionize: smObj.sectionize ?? true,
-            watchPaths: Array.isArray(smObj.watchPaths)
-                ? smObj.watchPaths
-                : [],
+            watchPaths: parseWatchPaths(smObj.watchPaths),
             debounceMs: smObj.debounceMs ?? 2000,
             maxAgeDays: smObj.maxAgeDays ?? 30,
             ignorePaths: Array.isArray(smObj.ignorePaths)

package/dist/graph/ops.js

@@ -1,8 +1,31 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { MOOD_WEATHER_SOURCE } from "../lib/filters.js";
 import { getAllUserIds } from "../lib/sender.js";
 import { log } from "../logger.js";
 const ENTITY_TYPES = ["people", "projects", "organizations", "topics"];
+/**
+ * True for memories that came from a Memory Network entity file synced back
+ * to Hyperspell. These must never re-enter a scan as source memories — the
+ * extractor would be fed its own output every cycle (self-scan loop,
+ * proposal/06 §3.3). Two signals, both needed:
+ * - `graph_entity` metadata, propagated from entity-file frontmatter by the
+ *   sync paths (`sync/markdown.ts`) — the contract the extraction prompt states;
+ * - the entity-directory `file_path`, which covers records synced before the
+ *   frontmatter propagation existed (unchanged sections are content-hash
+ *   skipped on re-sync, so their old metadata never gets refreshed).
+ */
+export function isEntityFileMemory(metadata) {
+    if (!metadata)
+        return false;
+    if (metadata.graph_entity === "true" || metadata.graph_entity === true)
+        return true;
+    const filePath = metadata.file_path;
+    if (typeof filePath !== "string")
+        return false;
+    const normalized = filePath.split(path.sep).join("/");
+    return ENTITY_TYPES.some((type) => normalized.includes(`/memory/${type}/`));
+}
 export function slugify(name) {
     return name
         .toLowerCase()
@@ -60,17 +83,27 @@ function summarizeMemoryData(data, source) {
     }
     return parts.join("\n");
 }
-export async function scanMemories(client, stateManager, batchSize, cfg) {
+export async function scanMemories(client, stateManager, batchSize, 
+// Required (not optional) so no caller can silently bypass the multiUser
+// fan-out again — the CLI `network scan` did exactly that (proposal/06 §3.3).
+cfg) {
     const unprocessed = [];
-    const userIds = cfg ? getAllUserIds(cfg) : [undefined];
+    // Single-user installs without a configured userId resolve to no ids;
+    // scan under the API key's default identity in that case.
+    const configuredIds = getAllUserIds(cfg);
+    const userIds = configuredIds.length > 0 ? configuredIds : [undefined];
     outer: for (const userId of userIds) {
         for await (const mem of client.listMemories({ userId })) {
             if (stateManager.isProcessed(mem.resourceId))
                 continue;
-            if (mem.metadata?.graph_entity === "true" || mem.metadata?.graph_entity === true)
+            if (isEntityFileMemory(mem.metadata))
                 continue;
             if (mem.metadata?.status !== "completed")
                 continue;
+            // Mood-weather roll records are observability-only (issue #71): the graph
+            // feeds context, so ingesting them would leak the rolls back into recall.
+            if (mem.metadata?.openclaw_source === MOOD_WEATHER_SOURCE)
+                continue;
             let summary = "";
             try {
                 const full = await client.getMemory(mem.resourceId, mem.source, { userId });

package/dist/hooks/auto-context.js

@@ -1,6 +1,7 @@
+import { appendFileSync } from "node:fs";
 import { buildScopeFilter, getCanReadScopes, resolveUser, } from "../lib/sender.js";
 import { excludeFilterFor, mergeWithExclude } from "../lib/filters.js";
-import { rerank, selectRanked } from "../lib/ranking.js";
+import { explainSelection, kindTally, rerank, } 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";
@@ -79,6 +80,49 @@ function formatSelected(selected, threshold) {
         return null;
     return sections.join("\n\n");
 }
+/**
+ * Opt-in score sampling for relevanceThreshold tuning (proposal 02 §3b).
+ * Writes one JSONL line per candidate when HYPERSPELL_SCORE_LOG names a file;
+ * review/analyze with docs/score-review.mjs and docs/score-analyze.mjs.
+ *
+ * The lines carry an 80-char prompt prefix and memory snippets — sensitive
+ * plaintext on disk — so this is OFF by default and never config-driven:
+ * it writes nothing unless the operator explicitly sets the env var (setting
+ * it IS the opt-in), and the log should be deleted after the tuning window.
+ * The env var is read at call time (not module load) so tests can set it.
+ * Must never throw into the retrieval path.
+ */
+function logScoreSamples(prompt, sessionId, scope, explained, threshold) {
+    const path = process.env.HYPERSPELL_SCORE_LOG;
+    if (!path || explained.length === 0)
+        return;
+    const ts = new Date().toISOString();
+    const lines = explained.map((e) => {
+        const r = e.result;
+        const top = [...r.highlights].sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+        return JSON.stringify({
+            ts,
+            sessionId,
+            scope,
+            prompt: prompt.slice(0, 80),
+            resourceId: r.resourceId,
+            title: (r.title ?? "").slice(0, 60),
+            kind: r._kind,
+            base: Number(r._base.toFixed(4)),
+            composite: Number(r._composite.toFixed(4)),
+            threshold,
+            selected: e.selected,
+            cut: e.cut,
+            snippet: (top?.text ?? "").replace(/\s+/g, " ").slice(0, 120),
+        });
+    });
+    try {
+        appendFileSync(path, `${lines.join("\n")}\n`);
+    }
+    catch {
+        // instrumentation must never break retrieval
+    }
+}
 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.";
 // A short, CONDITIONAL reminder appended only to a real memory block (not a
@@ -157,11 +201,34 @@ export function buildAutoContextHandler(client, cfg) {
                 const ranked = rerank(results, ranking);
                 // 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);
+                const explained = explainSelection(ranked, cfg.maxResults, cfg.relevanceThreshold, ranking.chatterQuota);
+                logScoreSamples(prompt, currentSessionId, "single", explained, cfg.relevanceThreshold);
+                const selected = explained.filter((e) => e.selected).map((e) => e.result);
+                // Candidates → selected kind tally, logged UNCONDITIONALLY (unlike the
+                // "injecting" line below): a story/curated match that loses to the
+                // threshold is exactly the case an operator tuning storyTerms needs to
+                // see, and it never reaches the formatted branch (proposal 01 §3.4).
+                log.diag(`auto-context: ranked ${JSON.stringify(kindTally(ranked))} candidates → selected ${JSON.stringify(kindTally(selected))} (chatter cap ${ranking.chatterQuota})`);
+                for (const r of ranked.slice(0, 10)) {
+                    log.debug(`  [${r._kind}] ${r._base.toFixed(2)}→${r._composite.toFixed(2)} ${(r.title ?? r.resourceId).slice(0, 60)}`);
+                }
+                // Cut-reason visibility (proposal 02, absorbs proposal 03): logged
+                // BEFORE the `formatted` check so quota drops stay visible even when
+                // nothing is injected (e.g. chatterQuota 0 with only chatter clearing
+                // the threshold). Stable "auto-context: cut" prefix for log greps.
+                // flatMap (not filter) so TS narrows to the cut member of the union.
+                const cuts = explained.flatMap((e) => (e.selected ? [] : [e]));
+                if (cuts.length > 0) {
+                    const cutTally = cuts.reduce((acc, e) => ((acc[e.cut] = (acc[e.cut] ?? 0) + 1), acc), {});
+                    const topQuotaDrop = cuts.find((e) => e.cut === "chatter-quota");
+                    const quotaNote = topQuotaDrop
+                        ? `, top quota-dropped composite ${topQuotaDrop.result._composite.toFixed(2)}`
+                        : "";
+                    log.diag(`auto-context: cut ${cuts.length} of ${ranked.length} candidates ${JSON.stringify(cutTally)}${quotaNote}`);
+                }
                 formatted = formatSelected(selected, cfg.relevanceThreshold);
                 if (formatted) {
-                    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})`);
+                    log.diag(`auto-context: injecting (ranked) ${JSON.stringify(kindTally(selected))} from ${results.length} candidates (chatter cap ${ranking.chatterQuota}, composite ${selected.at(-1)?._composite.toFixed(2)}–${selected[0]?._composite.toFixed(2)})`);
                 }
             }
             else {
@@ -188,6 +255,10 @@ export function buildAutoContextHandler(client, cfg) {
         }
     };
 }
+// Score logging / cut attribution (proposal 02) applies to the ranked
+// single-user path only: this path never runs rerank/explainSelection, so
+// there is no composite score to attribute. If ranking ever lands here, call
+// logScoreSamples with scope "personal" / "shared" per search.
 async function multiUserSearch(client, cfg, prompt, resolved, currentSessionId) {
     const multiUser = cfg.multiUser;
     const isKnownSender = !!resolved?.resolved;

package/dist/hooks/auto-trace.js

@@ -1,3 +1,4 @@
+import { channelIdFromCtx } from "../lib/exclude-channels.js";
 import { resolveUser } from "../lib/sender.js";
 import { isMultiSpeaker } from "../lib/speaker-tracker.js";
 import { log } from "../logger.js";
@@ -113,7 +114,14 @@ export function buildAutoTraceHandler(client, cfg) {
             log.debug(`auto-trace: skipping — conversation too short (${estimate} chars)`);
             return;
         }
-        const sessionId = event.sessionId ?? crypto.randomUUID();
+        // The session id lives on the hook CONTEXT, not the agent_end event (same
+        // contract issue #42 hit in hot-buffer): reading only event.sessionId
+        // yields a fresh random UUID per turn, which breaks multi-speaker
+        // detection keying and makes the openclaw_session_id tag useless for
+        // cleanup. Prefer ctx; keep event/random as fallbacks.
+        const sessionId = ctx?.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.
@@ -131,12 +139,22 @@ export function buildAutoTraceHandler(client, cfg) {
         // Falls back to sharedUserId for unknown senders (or undefined in single-user mode).
         const resolved = resolveUser(ctx, cfg);
         const userId = resolved?.userId;
+        // Tag traces with the conversation they came from. channelIdFromCtx is the
+        // same resolver the quarantine check uses, so tag-time identity matches
+        // quarantine-time identity — the purge-channel CLI relies on that parity.
+        // session_id is a first-class trace field but is NOT exposed by
+        // listMemories, so it's mirrored into metadata for enumeration.
+        const channelId = channelIdFromCtx(ctx);
         try {
             const result = await client.sendTrace(history, {
                 sessionId,
                 title,
                 extract: cfg.autoTrace.extract,
-                metadata: cfg.autoTrace.metadata,
+                metadata: {
+                    ...cfg.autoTrace.metadata,
+                    ...(channelId ? { openclaw_channel_id: channelId } : {}),
+                    openclaw_session_id: sessionId,
+                },
                 userId,
                 // Auto-trace captures full conversation text — the most sensitive class
                 // of memory. Default to private; users opt into family-visible recall

package/dist/hooks/emotional-state.js

@@ -1,10 +1,11 @@
+import { channelIdFromCtx } from "../lib/exclude-channels.js";
 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";
+import { buildMoodWeatherContext, recordMoodRoll, rollMood, } from "./mood-weather.js";
 /** How many recent registers to surface as the "arc" at session start. */
-const EMOTIONAL_ARC_LIMIT = 3;
+export const EMOTIONAL_ARC_LIMIT = 3;
 const MIN_MESSAGES = 3;
 const MIN_CONVERSATION_LENGTH = 100;
 /**
@@ -14,6 +15,12 @@ const MIN_CONVERSATION_LENGTH = 100;
  * heartbeat overwrite the register from a deep conversation (the whipsaw).
  * `ctx.trigger` is one of cron|heartbeat|manual|memory|overflow|user; we store
  * only for user-driven turns (and `overflow`, a continuation of a user run).
+ *
+ * Lifetime (verified against openclaw core, issue #70): `trigger` is PER-RUN,
+ * not session-fixed — core rebuilds the hook ctx from each run's own params
+ * (embedded-agent-runner/run.ts), and inbound human replies always start a new
+ * run with trigger="user" even inside a cron-originated session. So a scheduled
+ * check-in that becomes a real conversation IS stored on the human turns.
  */
 const NON_CONVERSATIONAL_TRIGGERS = new Set(["cron", "heartbeat", "memory"]);
 /**
@@ -24,6 +31,25 @@ const NON_CONVERSATIONAL_TRIGGERS = new Set(["cron", "heartbeat", "memory"]);
 const STORE_DEBOUNCE_MS = 3 * 60 * 1000;
 /** relationshipId → last successful store time (ms). Module-scoped, per process. */
 const lastStoreAt = new Map();
+/**
+ * Cross-session cooldown for mood weather: once weather actually LANDS, no new
+ * roll for this long, no matter how many sessions start. "Rare per session"
+ * isn't "rare" when sessions cluster — five short same-day sessions would
+ * otherwise get five independent rolls and can whiplash silly → spiky → flat
+ * in one afternoon. Weather changes on the scale of days, not sessions.
+ * Misses do NOT start the cooldown — only landed weather does, so effective
+ * frequency for unclustered sessions still tracks moodWeatherChance.
+ */
+export const MOOD_WEATHER_COOLDOWN_MS = 6 * 60 * 60 * 1000;
+/** relationshipId → when weather last actually landed (ms). Module-scoped, per process (mirrors lastStoreAt). */
+const lastMoodRollAt = new Map();
+/**
+ * sessionKey → the mood that landed for that session. Post-compaction
+ * re-injection must replay the SAME weather — not roll new dice (mood must
+ * stay stable for a whole session) and not silently drop it (the cooldown
+ * would otherwise suppress the re-roll mid-session).
+ */
+const sessionMoods = new Map();
 /**
  * Sessions where emotional context has already been injected this run.
  * Emotional state doesn't change within a session (it's extracted at
@@ -120,9 +146,14 @@ function relativeWhen(iso) {
  * backend doesn't expose `/emotional-state/recent` yet (returns null) or errors
  * — so this works before AND after that endpoint deploys.
  */
-async function fetchRecentOrLatest(client, cfg) {
+export async function fetchRecentOrLatest(client, cfg, limit) {
+    // An explicit caller-supplied limit (the hyperspell_emotional_arc tool) must
+    // always win outright; only the *default* when no limit is passed may depend
+    // on config (see #68's depth-weighted default) — a model's explicit ask
+    // should never be silently overridden by an unrelated config knob.
+    const fetchLimit = limit ?? EMOTIONAL_ARC_LIMIT;
     try {
-        const recent = await client.getRecentEmotionalStates(cfg.relationshipId, EMOTIONAL_ARC_LIMIT);
+        const recent = await client.getRecentEmotionalStates(cfg.relationshipId, fetchLimit);
         if (recent !== null)
             return recent; // endpoint available (may be empty)
     }
@@ -133,7 +164,7 @@ async function fetchRecentOrLatest(client, cfg) {
     return single ? [single] : [];
 }
 /** Build the injected emotional-context block from one or more registers. */
-function buildEmotionalContext(states) {
+export function buildEmotionalContext(states) {
     const intro = states.length > 1
         ? "How your relationship with this user has felt across your recent conversations, most recent first. Let the trajectory inform your tone — don't reference it explicitly."
         : "The emotional register of your relationship with this user from your last interaction. Let it inform your tone — don't reference it explicitly.";
@@ -156,7 +187,8 @@ function buildEmotionalContext(states) {
  *
  * Runs on `before_agent_start` (which fires every turn).
  */
-export function buildEmotionalStateFetchHandler(client, cfg) {
+export function buildEmotionalStateFetchHandler(client, cfg, deps = {}) {
+    const now = deps.now ?? Date.now;
     return async (_event, ctx) => {
         const sessionKey = ctx?.sessionKey;
         if (sessionKey && injectedSessions.has(sessionKey)) {
@@ -168,32 +200,57 @@ 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));
+            if (usable.length === 0 && states.length > 0) {
+                // State(s) exist but are all still extracting — don't cache, so a
+                // later turn re-fetches once extraction completes. Runs BEFORE the
+                // mood roll so a discarded turn can't land weather or burn the
+                // cross-session cooldown.
+                log.debug("emotional-context: state(s) still extracting — skipping injection this turn");
+                return;
+            }
             // 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
+            // arc's tone for this session only. Lives purely in the injection path —
             // 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) {
+            // Rolled once per session (inject-once cache) AND at most once per
+            // MOOD_WEATHER_COOLDOWN_MS across sessions (a landed roll suppresses new
+            // rolls; post-compaction re-injection replays the same mood instead).
+            const relId = cfg.relationshipId ?? "";
+            const priorMood = sessionKey ? sessionMoods.get(sessionKey) : undefined;
+            // Missing map entry means weather never landed this process — always
+            // eligible (don't subtract from an epoch the injectable clock may predate).
+            const lastLanded = lastMoodRollAt.get(relId);
+            const cooledDown = lastLanded === undefined || now() - lastLanded >= MOOD_WEATHER_COOLDOWN_MS;
+            const mood = priorMood ??
+                (cfg.moodWeatherChance > 0 && cooledDown
+                    ? rollMood(cfg.moodWeatherChance, deps.rng)
+                    : null);
+            if (mood && !priorMood) {
+                lastMoodRollAt.set(relId, now());
+                if (sessionKey)
+                    sessionMoods.set(sessionKey, mood);
                 log.info(`mood-weather: rolled "${mood.id}" this session`);
+                // Observability record (issue #71) — fire-and-forget, recall-excluded.
+                // Stays inside the !priorMood guard: a post-compaction replay of an
+                // already-rolled mood is NOT a new roll and must not double-log. Rolls
+                // only happen past the still-extracting early return above, so every
+                // recorded roll is one that actually lands in this session's context.
+                recordMoodRoll(client, mood, {
+                    sessionKey,
+                    relationshipId: cfg.relationshipId,
+                });
             }
+            const moodBlock = mood ? buildMoodWeatherContext(mood) : "";
             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. (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 moodBlock ? { prependContext: moodBlock } : undefined;
             }
-            log.debug(`emotional-context: injecting ${usable.length} recent register(s)`);
+            // log.diag, not debug: the exact line issue #118's live audit proved
+            // invisible — one line per injection, operator-meaningful.
+            log.diag(`emotional-context: injecting ${usable.length} recent register(s)`);
             // 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
@@ -228,8 +285,12 @@ export function buildEmotionalStateCompactionHandler() {
 export function buildEmotionalStateSessionCleanupHandler() {
     return async (_event, ctx) => {
         const sessionKey = ctx?.sessionKey;
-        if (sessionKey)
+        if (sessionKey) {
             injectedSessions.delete(sessionKey);
+            // Session over — its mood memo is dead weight. NOT cleared on
+            // compaction: surviving compaction is what makes the mood replay.
+            sessionMoods.delete(sessionKey);
+        }
     };
 }
 /**
@@ -276,9 +337,16 @@ export function buildEmotionalStateStoreHandler(client, cfg) {
             return;
         }
         try {
+            // Tag the register with the medium it was extracted from (voice vs Discord vs
+            // DM), mirroring hot-buffer's openclaw_channel_id tag. Capture-only: analysis/
+            // debugging metadata, deliberately NOT surfaced in the injected prose (#74).
+            const channelId = channelIdFromCtx(ctx);
             const result = await client.storeEmotionalState(transcript, {
                 relationshipId: cfg.relationshipId,
-                metadata: { source: "openclaw_agent_end" },
+                metadata: {
+                    source: "openclaw_agent_end",
+                    ...(channelId ? { channelId } : {}),
+                },
             });
             lastStoreAt.set(relId, Date.now());
             log.info(`emotional-state: stored ${result.resourceId}`);