feat(verif): VADER -> user_mood EMA hook in remember (closes MOOD_CONGRUENT signal gap)

Without this hook the user_mood table (added in b4b23e7) sat at 0.0
forever and MOOD_CONGRUENT_RERANK no-oped despite end-to-end wiring.
The hook reuses the existing VADER analyzer in write_gate.tag_memory_emotions
(Wang & Bhatt 2024) and EMA-updates user_mood with alpha=0.3 (engineering
default, pending calibration). Ablation guard added for symmetry.

Source: Bower (1981) "Mood and Memory" Am. Psychologist 36(2). VADER
compound from Hutto & Gilbert (ICWSM 2014). EMA structural form follows
prior Cortex thermodynamic conventions.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cdeust

mcp_server/handlers/remember.py

@@ -17,6 +17,7 @@
     evaluate_gate,
     insert_and_post_process,
     try_curation,
+    update_user_mood_ema,
 )
 from mcp_server.handlers.remember_response import build_merge_response
 from mcp_server.infrastructure import wiki_store
@@ -330,6 +331,9 @@ async def _handler_impl(args: dict[str, Any] | None = None) -> dict[str, Any]:
         content, embedding, force, store, emb_engine, tags, mod["heat"]
     )
     if action == "merge":
+        # Mood signal still updates on merge — the user authored the content,
+        # whether we keep it as a new row or fold it into an existing one.
+        update_user_mood_ema(content, source, store)
         return build_merge_response(mid, domain, mod, gate)
 
     result = insert_and_post_process(
@@ -357,6 +361,14 @@ async def _handler_impl(args: dict[str, Any] | None = None) -> dict[str, Any]:
         result["is_global"] = True
         result["global_reason"] = global_reason
 
+    # MOOD_CONGRUENT_RERANK signal-feed (Bower 1981 mood-congruent recall):
+    # EMA-update user_mood.valence from VADER compound on user-authored
+    # content. Non-user sources are ignored to keep the signal faithful
+    # to the user's affective state. See remember_helpers.update_user_mood_ema
+    # for the contract and source-discipline notes.
+    if result.get("stored"):
+        update_user_mood_ema(content, source, store)
+
     # Promote decision-shaped memories to the authored wiki layer.
     #
     # Contract (E8, post-Taleb fragility audit):

mcp_server/handlers/remember_helpers.py

@@ -14,6 +14,8 @@
     write_gate_calibration,
     write_post_store,
 )
+from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+from mcp_server.shared.vader import vader_compound
 from mcp_server.core.dual_store_cls import classify_memory
 from mcp_server.core.predictive_coding_flat import (
     compute_embedding_novelty,
@@ -411,3 +413,69 @@ def insert_and_post_process(
         sep,
         interf,
     )
+
+
+# ── User-mood EMA hook (Bower 1981 mood-congruent recall, signal side) ──
+# Engineering default; calibration pending future work — Bower (1981)
+# "Mood and Memory" Am. Psychologist 36(2) prescribes mood-congruent
+# recall qualitatively, not the time-constant of mood drift. No published
+# psychophysics constant for the EMA decay of self-report mood at the
+# session timescale was located (April 2026). Conservative default
+# matches the structural form of other Cortex EMAs (write_gate_calibration).
+# When a published value is found, replace this constant and cite.
+MOOD_EMA_ALPHA: float = 0.3
+
+
+def update_user_mood_ema(
+    content: str,
+    source: str,
+    store: MemoryStore,
+) -> float | None:
+    """EMA-update the user's session-level mood from VADER on user content.
+
+    Contract:
+      pre:  content is a hardened, non-empty string; source is one of the
+            remember.py source enum values; store exposes get_user_mood /
+            set_user_mood (real PgMemoryStore or duck-compatible stub).
+      post: when source == "user" AND MOOD_CONGRUENT_RERANK is NOT ablated,
+            user_mood.valence is upserted to
+                (1 - α) * old + α * vader_compound(content)
+            with α = MOOD_EMA_ALPHA, old defaulting to 0.0 when the row
+            is absent. Returns the new valence on update, or None when
+            skipped (non-user source, ablated, or store missing API).
+            Never raises — failures are swallowed and reported as None.
+
+    Source-discipline notes:
+      - VADER compound: Hutto & Gilbert, ICWSM 2014.
+      - Mood-congruent recall: Bower 1981 Am. Psychologist 36(2).
+      - α = 0.3: engineering default (see module-level comment above).
+
+    User-side definition (self-flagged risk addressed):
+      Only source == "user" updates mood. System-generated memories
+      (source ∈ {"tool", "consolidation", "import"}) and conversational
+      transcripts (source == "session", which is mixed agent/user)
+      do NOT mutate user_mood, because their content does not reflect
+      the user's affective state at recall time.
+
+      Ablation symmetry: when CORTEX_ABLATE_MOOD_CONGRUENT_RERANK=1,
+      we also skip the write so the table doesn't accumulate signal
+      that's then ignored downstream (clean ablation deltas).
+    """
+    if source != "user":
+        return None
+    if is_mechanism_disabled(Mechanism.MOOD_CONGRUENT_RERANK):
+        return None
+    if not hasattr(store, "set_user_mood") or not hasattr(store, "get_user_mood"):
+        return None
+    try:
+        compound = vader_compound(content)
+        old = store.get_user_mood()
+        old_valence = 0.0 if old is None else float(old)
+        new_valence = (1.0 - MOOD_EMA_ALPHA) * old_valence + MOOD_EMA_ALPHA * compound
+        # Clamp defensively; set_user_mood clamps too, but we want the
+        # returned value to match what was persisted.
+        new_valence = max(-1.0, min(1.0, new_valence))
+        store.set_user_mood(new_valence)
+        return new_valence
+    except Exception:  # noqa: BLE001 — non-load-bearing; mood is a soft signal
+        return None

tasks/smoke_user_mood_ema.py

@@ -0,0 +1,129 @@
+"""Smoke: VADER → user_mood EMA hook + MOOD_CONGRUENT_RERANK delta.
+
+End-to-end signal path on a stub store (no live PG required):
+
+  1. remember() with a positive-valence message → user_mood drifts positive
+  2. remember() with a negative-valence message → user_mood drifts back
+  3. mood_congruent_rerank with the EMA-driven mood produces score deltas
+     vs the same call with user_mood=None
+  4. CORTEX_ABLATE_MOOD_CONGRUENT_RERANK=1 short-circuits (identity)
+
+Run:
+    uv run python tasks/smoke_user_mood_ema.py
+"""
+
+from __future__ import annotations
+
+import os
+
+from mcp_server.core.recall_pipeline import mood_congruent_rerank
+from mcp_server.handlers.remember_helpers import (
+    MOOD_EMA_ALPHA,
+    update_user_mood_ema,
+)
+from mcp_server.shared.vader import vader_compound
+
+
+class _MoodStore:
+    def __init__(self) -> None:
+        self.valence: float | None = None
+
+    def get_user_mood(self) -> float | None:
+        return self.valence
+
+    def set_user_mood(self, valence: float, arousal: float = 0.0) -> None:
+        self.valence = max(-1.0, min(1.0, float(valence)))
+
+
+def _candidates() -> list[dict]:
+    """Five candidates in increasing emotional_valence."""
+    return [
+        {
+            "memory_id": i,
+            "content": f"mem {i}",
+            "score": 1.0 / (i + 1),
+            "heat": 0.5,
+            "tags": [],
+            "domain": "smoke",
+            "created_at": "2026-04-30T00:00:00Z",
+            "emotional_valence": v,
+        }
+        for i, v in enumerate([-0.9, -0.5, 0.0, +0.5, +0.9])
+    ]
+
+
+def main() -> None:
+    print(f"MOOD_EMA_ALPHA = {MOOD_EMA_ALPHA}")
+    store = _MoodStore()
+
+    pos_msg = "Wonderful breakthrough! I am thrilled and delighted with this success."
+    neg_msg = "This is terrible. I hate this awful broken garbage. Frustrated and angry."
+
+    print(f"\n[1] vader_compound(positive) = {vader_compound(pos_msg):+.4f}")
+    print(f"    vader_compound(negative) = {vader_compound(neg_msg):+.4f}")
+
+    print("\n[2] EMA progression — positive then negative messages:")
+    print(f"    initial mood:               {store.valence}")
+    new = update_user_mood_ema(pos_msg, source="user", store=store)
+    print(f"    after positive (user):      {new:+.4f}")
+    new = update_user_mood_ema(pos_msg, source="user", store=store)
+    print(f"    after positive (user):      {new:+.4f}")
+    new = update_user_mood_ema(neg_msg, source="user", store=store)
+    print(f"    after negative (user):      {new:+.4f}")
+
+    print("\n[3] Source gating — non-user sources do NOT update mood:")
+    pre = store.valence
+    for src in ("tool", "consolidation", "import", "session"):
+        result = update_user_mood_ema(pos_msg, source=src, store=store)
+        print(f"    source={src:14s} → returned {result}, mood still {store.valence:+.4f}")
+    assert store.valence == pre, "non-user source must not mutate mood"
+
+    print("\n[4] Drive mood strongly positive for rerank delta test:")
+    for _ in range(5):
+        update_user_mood_ema(pos_msg, source="user", store=store)
+    print(f"    mood after 5 positive iters: {store.valence:+.4f}")
+
+    cands = _candidates()
+    baseline = mood_congruent_rerank(cands, user_mood=None)
+    active = mood_congruent_rerank(cands, user_mood=store.valence)
+    base_scores = {c["memory_id"]: c["score"] for c in baseline}
+    active_scores = {c["memory_id"]: c["score"] for c in active}
+
+    print("\n[5] mood_congruent_rerank deltas (positive mood):")
+    print(f"    {'id':>3}  {'valence':>8}  {'baseline':>10}  {'active':>10}  {'Δ':>10}")
+    for cid in sorted(base_scores):
+        v = next(c["emotional_valence"] for c in cands if c["memory_id"] == cid)
+        bs, as_ = base_scores[cid], active_scores[cid]
+        print(f"    {cid:>3}  {v:+8.2f}  {bs:>10.6f}  {as_:>10.6f}  {as_-bs:>+10.6f}")
+
+    delta_congruent = active_scores[4] - base_scores[4]   # high +valence
+    delta_incongruent = active_scores[0] - base_scores[0]  # high -valence
+    print(
+        f"\n    Δ congruent  (id=4, valence +0.9): {delta_congruent:+.6f}"
+        f"\n    Δ incongruent(id=0, valence -0.9): {delta_incongruent:+.6f}"
+    )
+    assert delta_congruent > delta_incongruent, "mood-congruent must gain more"
+    assert base_scores != active_scores, "rerank must produce a non-identity delta"
+    print("    ✓ mood-congruent candidate gains MORE than incongruent")
+    print("    ✓ rerank produces score deltas (NOT identity)")
+
+    print("\n[6] Ablation symmetry — CORTEX_ABLATE_MOOD_CONGRUENT_RERANK=1:")
+    abl_store = _MoodStore()
+    os.environ["CORTEX_ABLATE_MOOD_CONGRUENT_RERANK"] = "1"
+    try:
+        result = update_user_mood_ema(pos_msg, source="user", store=abl_store)
+        assert result is None, "EMA write must be skipped when ablated"
+        assert abl_store.valence is None, "store must be untouched"
+        print(f"    EMA hook returned {result}, store.valence = {abl_store.valence}")
+        # And rerank itself short-circuits
+        active_abl = mood_congruent_rerank(cands, user_mood=+0.7)
+        assert active_abl == cands, "rerank must be identity when ablated"
+        print("    ✓ rerank stage returns identity when ablated")
+    finally:
+        os.environ.pop("CORTEX_ABLATE_MOOD_CONGRUENT_RERANK", None)
+
+    print("\n✓ smoke OK — VADER → user_mood EMA hook is wired and signal-fed.")
+
+
+if __name__ == "__main__":
+    main()

tests_py/core/test_pg_recall_pipeline.py

@@ -450,6 +450,85 @@ def test_mood_congruent_active_promotes_congruent_valence():
     assert out_ids.index(0) < out_ids.index(3)
 
 
+def test_mood_congruent_ema_driven_path_produces_delta():
+    """End-to-end signal path: EMA hook → user_mood → mood_congruent_rerank.
+
+    The hook in remember_helpers.update_user_mood_ema feeds VADER compound
+    into user_mood; the rerank stage then consumes user_mood at recall time.
+    This test exercises the full chain on a stub store and confirms a
+    non-identity reorder vs the no-mood (None) baseline. Closes the wiring
+    gap that left MOOD_CONGRUENT_RERANK signal-fed but unwired in production.
+    """
+    from mcp_server.handlers.remember_helpers import update_user_mood_ema
+
+    class _Store:
+        def __init__(self) -> None:
+            self.valence: float | None = None
+
+        def get_user_mood(self) -> float | None:
+            return self.valence
+
+        def set_user_mood(self, valence: float, arousal: float = 0.0) -> None:
+            self.valence = max(-1.0, min(1.0, float(valence)))
+
+    store = _Store()
+    # Drive several positive user-authored messages through the EMA hook so
+    # mood drifts strongly positive. Single message at α=0.3 only reaches
+    # ~0.3 * compound, so we feed 3 to amplify above the rerank threshold.
+    for _ in range(3):
+        update_user_mood_ema(
+            "Wonderful breakthrough! I am thrilled and delighted with this success.",
+            source="user",
+            store=store,
+        )
+    assert store.valence is not None and store.valence > 0.2
+
+    # Candidate set where base score order is INVERSE of valence so that
+    # an active mood-congruent rerank reshuffles them. Candidate 0 has the
+    # lowest base score but the most positive valence; positive user mood
+    # should boost it above candidate 4 (highest base score, negative valence).
+    # Input order is the relevance rank (_rrf_blend uses positional rank,
+    # not score). Order: negative-valence first, positive-valence last —
+    # active positive mood should pull positive candidates upward.
+    cands = [
+        {
+            "memory_id": i,
+            "content": f"mem {i}",
+            "score": 1.0 / (i + 1),
+            "heat": 0.5,
+            "tags": [],
+            "domain": "test",
+            "created_at": "2026-04-30T00:00:00Z",
+            "emotional_valence": v,
+        }
+        for i, v in enumerate([-0.9, -0.5, 0.0, +0.5, +0.9])
+    ]
+    baseline = mood_congruent_rerank(cands, user_mood=None)
+    active = mood_congruent_rerank(cands, user_mood=store.valence)
+    # Baseline is identity (input order); active must produce score deltas
+    # — even if positional ranks are unchanged, the RRF blend assigns new
+    # scores reflecting valence-mood congruence. That score signal is what
+    # downstream stages (FlashRank, per-type pools) consume.
+    base_scores = {c["memory_id"]: c["score"] for c in baseline}
+    active_scores = {c["memory_id"]: c["score"] for c in active}
+    assert base_scores != active_scores, (
+        "EMA-driven mood must produce score deltas vs no-mood baseline"
+    )
+    # The most mood-congruent candidate (id=4, valence +0.9) must gain
+    # score relative to its no-mood baseline; the most incongruent (id=0,
+    # valence -0.9) must lose. We compare the active-vs-baseline ratio,
+    # not absolute order — at default blend_beta=0.15 with positional
+    # rank dominance (k=60), the relevance order is preserved, but the
+    # delta direction is observable and is the signal downstream stages
+    # (FlashRank, per-type pools) consume.
+    delta_congruent = active_scores[4] - base_scores[4]
+    delta_incongruent = active_scores[0] - base_scores[0]
+    assert delta_congruent > delta_incongruent, (
+        f"mood-congruent candidate must gain MORE than incongruent: "
+        f"id=4 Δ={delta_congruent:.6f}, id=0 Δ={delta_incongruent:.6f}"
+    )
+
+
 # ── RECONSOLIDATION (Nader 2000) ───────────────────────────────────────