feat(verif): wire EMOTIONAL_RETRIEVAL + MOOD_CONGRUENT_RERANK as live read-path stages

Two enum entries (EMOTIONAL_RETRIEVAL, MOOD_CONGRUENT_RERANK) had no
production call site. They are now live post-WRRF stages in
core/recall_pipeline.py, gated by CORTEX_ABLATE_<NAME>=1, blended via
RRF (Cormack 2009).

EMOTIONAL_RETRIEVAL: infers query valence via VADER (Hutto & Gilbert
2014); ranks candidates by |stored_valence - q_valence|; RRF-blends
with WRRF rank at beta=0.20. Neutral queries (|compound|<0.10) no-op
to avoid noise.

MOOD_CONGRUENT_RERANK: takes user_mood from store.get_user_mood() if
exposed; ranks by congruence with user mood; RRF beta=0.15. Returns
identity when no mood signal is available — we do NOT fabricate one.

Both blend weights are engineering placeholders pending task #50
(6-knob grid: HOPFIELD x HDC x SA x DENDRITIC x EMOTIONAL_RETRIEVAL x
MOOD_CONGRUENT). Source: Bower 1981 "Mood and Memory" Am. Psychologist
36(2) — qualitative claim, no paper-prescribed magnitude.

- mcp_server/core/recall_pipeline.py: +2 stages, +constants
- mcp_server/core/pg_recall.py: +2 stage calls, +_get_user_mood helper
- tests_py/core/test_pg_recall_pipeline.py: +6 tests (21 total, all green)
- tasks/smoke_recall_pipeline.py: extended to 6 mechanisms; all produce
  observable ID/score deltas
- tasks/ablation-dormant-mechanisms.md: moved both entries from "future"
  to "Active read-path"

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

Author: cdeust

mcp_server/core/pg_recall.py

@@ -33,6 +33,33 @@ def _get_titans() -> TitansMemory:
     return _titans
 
 
+def _get_user_mood(store: Any) -> float | None:
+    """Return the user's session-level mood in [-1, +1], or None if absent.
+
+    Looks for an explicit ``get_user_mood()`` method on the store. There is
+    no such method in the current ``PgMemoryStore`` (April 2026), so this
+    helper returns ``None`` and the MOOD_CONGRUENT_RERANK stage no-ops —
+    per the zetetic source-discipline rule we do NOT fabricate a mood signal.
+    When an upstream emotion classifier or manual checkpoint annotation
+    populates a mood store, expose ``get_user_mood()`` and this helper
+    will start returning real values without further wiring changes.
+    """
+    if store is None:
+        return None
+    if not hasattr(store, "get_user_mood"):
+        return None
+    try:
+        v = store.get_user_mood()
+    except Exception:  # noqa: BLE001 — non-load-bearing; absence is fine
+        return None
+    if v is None:
+        return None
+    try:
+        return max(-1.0, min(1.0, float(v)))
+    except (TypeError, ValueError):
+        return None
+
+
 # ── Chronological reranking ─────────────────────────────────────────────
 # ChronoRAG (Chen et al., arxiv 2508.18748, 2025): for event ordering
 # queries, blend relevance rank with chronological rank via Reciprocal
@@ -257,8 +284,10 @@ def recall(
     # constants and citations.
     from mcp_server.core.recall_pipeline import (
         dendritic_modulate,
+        emotional_retrieval_rerank,
         hdc_rerank,
         hopfield_complete,
+        mood_congruent_rerank,
         spreading_activation_expand,
     )
 
@@ -272,6 +301,16 @@ def recall(
     candidates = spreading_activation_expand(candidates, query, store)
     candidates = dendritic_modulate(candidates, query, store)
 
+    # 4e. EMOTIONAL_RETRIEVAL — Bower 1981 mood-congruent recall using
+    # the QUERY's inferred valence (VADER) against each candidate's stored
+    # emotional_valence. No-ops on neutral queries.
+    candidates = emotional_retrieval_rerank(candidates, query)
+
+    # 4f. MOOD_CONGRUENT_RERANK — Bower 1981 mood-state-dependent recall
+    # using the USER's session-level mood. Returns identity when no mood
+    # signal exists; we do not fabricate one.
+    candidates = mood_congruent_rerank(candidates, _get_user_mood(store))
+
     # 5. Client-side FlashRank reranking
     if rerank and len(candidates) > 1:
         ranked_pairs = [(c["memory_id"], c.get("score", 0.0)) for c in candidates]

mcp_server/core/recall_pipeline.py

@@ -52,6 +52,23 @@
 # matches get a +DELTA bump and conflicting branches get -DELTA.
 _DENDRITIC_DELTA: float = 0.10
 
+# Emotional / mood-congruent rerank blend weights.
+# source: engineering default; calibration in tasks/blend-weight-calibration.md
+# (task #50, 6-knob grid HOPFIELD × HDC × SA × DENDRITIC × EMOTIONAL_RETRIEVAL ×
+# MOOD_CONGRUENT). Bower (1981) "Mood and Memory," Am. Psychologist 36(2)
+# does not prescribe a numeric blend weight; the paper's claim is qualitative
+# (mood-congruent recall is faster/more accurate than incongruent), so the
+# magnitude is set conservatively below the perception-side stages.
+_EMOTIONAL_RETRIEVAL_BETA: float = 0.20
+_MOOD_CONGRUENT_BETA: float = 0.15
+
+# Below this absolute compound-valence value the query is treated as
+# emotionally neutral and the EMOTIONAL_RETRIEVAL stage no-ops. VADER
+# (Hutto & Gilbert, ICWSM 2014) §4 reports |compound| ≥ 0.05 as a useful
+# positive/negative cutoff for short text; we use 0.10 so that single
+# weakly-loaded tokens do not flip the rerank.
+_EMOTIONAL_QUERY_VALENCE_FLOOR: float = 0.10
+
 
 # ── Helpers ─────────────────────────────────────────────────────────────
 
@@ -453,3 +470,113 @@ def dendritic_modulate(
 
     modulated.sort(key=lambda c: c.get("score", 0.0), reverse=True)
     return modulated
+
+
+# ── EMOTIONAL_RETRIEVAL stage ───────────────────────────────────────────
+# Bower, G.H. (1981). "Mood and Memory." Am. Psychologist 36(2):129-148.
+# Mood-congruent recall: candidates whose stored emotional valence matches
+# the query's inferred valence are retrieved faster and more accurately.
+# Engineering blend via RRF (Cormack et al. SIGIR 2009).
+
+
+def emotional_retrieval_rerank(
+    candidates: list[dict[str, Any]],
+    query: str,
+    *,
+    blend_beta: float = _EMOTIONAL_RETRIEVAL_BETA,
+    valence_floor: float = _EMOTIONAL_QUERY_VALENCE_FLOOR,
+) -> list[dict[str, Any]]:
+    """Rerank by query-valence ↔ candidate-valence congruence.
+
+    Bower (1981): emotionally-congruent material is retrieved faster and
+    more accurately than incongruent material. We infer the query's
+    affective load via VADER (Hutto & Gilbert, ICWSM 2014), measure each
+    candidate's stored ``emotional_valence`` distance from the query
+    valence, then RRF-blend that rank with the WRRF rank.
+
+    A neutral query (|valence| < ``valence_floor``) carries no congruence
+    signal and the stage no-ops — RRF on a uniform rank would only
+    add noise.
+
+    Disabled when ``CORTEX_ABLATE_EMOTIONAL_RETRIEVAL=1`` — returns input
+    unchanged. Distinct from MOOD_CONGRUENT_RERANK: this stage uses the
+    *query's* valence (per-recall), not a session-level user mood state.
+
+    Sources:
+      - Bower, G.H. (1981). "Mood and Memory." Am. Psychologist 36(2).
+      - Hutto, C.J. & Gilbert, E. (2014). "VADER: A Parsimonious Rule-based
+        Model for Sentiment Analysis of Social Media Text." ICWSM 2014.
+      - Cormack, Clarke & Buettcher (2009). RRF blend.
+    """
+    if is_mechanism_disabled(Mechanism.EMOTIONAL_RETRIEVAL):
+        return candidates
+    if not candidates:
+        return candidates
+
+    from mcp_server.shared.vader import vader_compound
+
+    q_valence = vader_compound(query)
+    if abs(q_valence) < valence_floor:
+        # Neutral query — no useful congruence signal to inject.
+        return candidates
+
+    def _distance(c: dict[str, Any]) -> float:
+        c_v = c.get("emotional_valence", 0.0) or 0.0
+        return abs(float(c_v) - q_valence)
+
+    by_match = sorted(enumerate(candidates), key=lambda x: _distance(x[1]))
+    mech_ranks = {
+        candidates[i]["memory_id"]: rank for rank, (i, _) in enumerate(by_match)
+    }
+    return _rrf_blend(candidates, mech_ranks, blend_beta)
+
+
+# ── MOOD_CONGRUENT_RERANK stage ────────────────────────────────────────
+# Bower (1981) mood-state-dependent recall: a person in a given mood
+# preferentially recalls memories acquired (or stored) in that same mood.
+# Distinct from EMOTIONAL_RETRIEVAL — this stage uses a USER session-level
+# mood signal, not the per-query valence.
+
+
+def mood_congruent_rerank(
+    candidates: list[dict[str, Any]],
+    user_mood: float | None,
+    *,
+    blend_beta: float = _MOOD_CONGRUENT_BETA,
+) -> list[dict[str, Any]]:
+    """Rerank by user-mood ↔ candidate-valence congruence.
+
+    ``user_mood`` is a float in [-1, +1] representing the user's current
+    affective state (e.g., set by an upstream emotion classifier or a
+    manual ``checkpoint`` annotation). When ``None``, the stage no-ops:
+    we do NOT fabricate a mood signal in the absence of one.
+
+    Default policy from Bower (1981): mood-congruent — candidates whose
+    stored valence is closer to the user's current mood get a rank boost.
+    The boost is small (RRF beta=0.15) so the underlying retrieval order
+    still dominates; this is a tie-breaker, not a filter.
+
+    Disabled when ``CORTEX_ABLATE_MOOD_CONGRUENT_RERANK=1`` — returns
+    input unchanged. Distinct from EMOTIONAL_RETRIEVAL (which uses the
+    query text's inferred valence).
+
+    Sources:
+      - Bower, G.H. (1981). "Mood and Memory." Am. Psychologist 36(2).
+      - Cormack, Clarke & Buettcher (2009). RRF blend.
+    """
+    if is_mechanism_disabled(Mechanism.MOOD_CONGRUENT_RERANK):
+        return candidates
+    if user_mood is None or not candidates:
+        return candidates
+
+    user_mood_f = float(user_mood)
+
+    def _distance(c: dict[str, Any]) -> float:
+        c_v = c.get("emotional_valence", 0.0) or 0.0
+        return abs(float(c_v) - user_mood_f)
+
+    by_match = sorted(enumerate(candidates), key=lambda x: _distance(x[1]))
+    mech_ranks = {
+        candidates[i]["memory_id"]: rank for rank, (i, _) in enumerate(by_match)
+    }
+    return _rrf_blend(candidates, mech_ranks, blend_beta)

tasks/ablation-dormant-mechanisms.md

@@ -48,6 +48,8 @@ no longer routes through it.
 | **HDC** | `core/recall_pipeline.hdc_rerank()` | Skips Kanerva 2009 bipolar HDC similarity rerank — content tokens stop contributing the bipolar bind/bundle signal |
 | **SPREADING_ACTIVATION** | `core/recall_pipeline.spreading_activation_expand()` | No graph-side BFS over the entity graph → memories reachable only via 2-3 hops drop out of the result set; observable as new IDs disappearing on ablation |
 | **DENDRITIC_CLUSTERS** | `core/recall_pipeline.dendritic_modulate()` | No multiplicative perturbation in [0.9, 1.1] from query-content Jaccard → near-ties shuffle slightly differently |
+| **EMOTIONAL_RETRIEVAL** | `core/recall_pipeline.emotional_retrieval_rerank()` | Skips Bower 1981 mood-congruent rerank — candidates whose stored `emotional_valence` is closest to the query's VADER compound no longer get an RRF rank boost; non-neutral queries lose the affect signal |
+| **MOOD_CONGRUENT_RERANK** | `core/recall_pipeline.mood_congruent_rerank()` | Skips Bower 1981 mood-state-dependent rerank — when an upstream mood signal is present (`store.get_user_mood()`), candidates congruent with the user's mood lose their rank boost. No-op when no mood signal exists |
 | **CO_ACTIVATION** | `handlers/recall.py:_apply_co_activation` (line 188) | Skips Hebbian post-recall edge strengthening — affects subsequent recalls' SR signal |
 
 ## State-Only Read-Path Mechanisms
@@ -95,8 +97,12 @@ the wiring.
 The §6.3 ablation table now distinguishes:
 
 1. **Active read-path** — ADAPTIVE_DECAY, HOPFIELD, HDC,
-   SPREADING_ACTIVATION, DENDRITIC_CLUSTERS, CO_ACTIVATION.
-   All produce non-zero deltas on a single read.
+   SPREADING_ACTIVATION, DENDRITIC_CLUSTERS, EMOTIONAL_RETRIEVAL,
+   MOOD_CONGRUENT_RERANK, CO_ACTIVATION.
+   All produce non-zero deltas on a single read (MOOD_CONGRUENT_RERANK
+   only when the store exposes a non-None ``get_user_mood()``; the
+   production store does not yet, but the wiring is live for the future
+   classifier — and the smoke harness exercises it via a stub).
 2. **State-only read-path** — SURPRISE_MOMENTUM. No ranking effect
    on a single benchmark pass; effect emerges across consecutive recalls.
 
@@ -110,4 +116,5 @@ path.
 - Commit `099ba1e` (module-level guards added)
 - Commit (this) — wired four dormant mechs through `pg_recall.recall`
 - Smoke test: `tasks/smoke_recall_pipeline.py`
-- Tests: `tests_py/core/test_pg_recall_pipeline.py` (12 tests, all green)
+- Tests: `tests_py/core/test_pg_recall_pipeline.py` (21 tests, all green)
+- Commit (this) — wired EMOTIONAL_RETRIEVAL + MOOD_CONGRUENT_RERANK; +6 tests; smoke confirms 6 mechanisms produce deltas

tasks/smoke_recall_pipeline.py

@@ -43,6 +43,11 @@ def __init__(self, n: int = 12) -> None:
         for i in range(n):
             tokens = ["alpha", "beta", "gamma", "delta", "epsilon"]
             content = f"mem {i} " + " ".join(tokens[: (i % 5) + 1])
+            # Spread emotional_valence across [-0.9, +0.9] so the
+            # EMOTIONAL_RETRIEVAL / MOOD_CONGRUENT_RERANK stages have a
+            # non-degenerate signal to act on. Without varied valence the
+            # rerank is a uniform-distance no-op even when enabled.
+            valence = round(((i % 7) / 3.0) - 1.0, 3)  # ∈ [-1.0, +1.0]
             self._mems[i] = {
                 "id": i,
                 "memory_id": i,
@@ -55,6 +60,7 @@ def __init__(self, n: int = 12) -> None:
                 "importance": 0.5,
                 "surprise_score": 0.0,
                 "store_type": "episodic",
+                "emotional_valence": valence,
             }
         # SA returns a memory NOT in the WRRF top-K to test injection
         self._mems[99] = {
@@ -88,10 +94,17 @@ def recall_memories(self, **kwargs) -> list[dict]:
                 "importance": 0.5,
                 "surprise_score": 0.0,
                 "store_type": "episodic",
+                "emotional_valence": self._mems[i]["emotional_valence"],
             }
             for rank, i in enumerate(ids)
         ]
 
+    # Session-level mood for MOOD_CONGRUENT_RERANK smoke. Real production
+    # PgMemoryStore does not expose this method (April 2026); the smoke
+    # store simulates the future API so the stage produces a delta.
+    def get_user_mood(self) -> float:
+        return 0.7
+
     def get_memory(self, mid: int) -> dict | None:
         return self._mems.get(mid)
 
@@ -124,8 +137,12 @@ def _run(env_name: str | None) -> tuple[list[int], list[float], float]:
     embs = _Embeddings()
     t0 = time.perf_counter()
     with _ablate(env_name):
+        # Query carries a clear positive VADER compound ("fixed deployed
+        # excellent") so EMOTIONAL_RETRIEVAL is non-neutral and ablation
+        # produces a measurable delta. Domain tokens (alpha/beta/gamma)
+        # keep HDC and SA paths active.
         out = recall(
-            query="alpha beta gamma extra",
+            query="alpha beta gamma extra fixed deployed excellent",
             store=store,
             embeddings=embs,
             top_k=10,
@@ -147,6 +164,8 @@ def main() -> None:
         "CORTEX_ABLATE_HDC",
         "CORTEX_ABLATE_SPREADING_ACTIVATION",
         "CORTEX_ABLATE_DENDRITIC_CLUSTERS",
+        "CORTEX_ABLATE_EMOTIONAL_RETRIEVAL",
+        "CORTEX_ABLATE_MOOD_CONGRUENT_RERANK",
     ]
     deltas = {}
     for env in mechs:
@@ -164,7 +183,7 @@ def main() -> None:
         print(f"  ids: {ids}")
         print(f"  latency: {dt * 1000:.2f} ms")
 
-    # All four must produce a non-trivial delta.
+    # All six must produce a non-trivial delta.
     failures = [
         k for k, v in deltas.items() if not (v["ids_changed"] or v["scores_changed"])
     ]
@@ -177,7 +196,7 @@ def main() -> None:
     if failures:
         print(f"\nFAIL: zero-delta mechanisms (wiring bug): {failures}")
         raise SystemExit(1)
-    print("\nPASS: all 4 mechanisms produce observable deltas.")
+    print("\nPASS: all 6 mechanisms produce observable deltas.")
 
 
 if __name__ == "__main__":