superlocalmemory 3.3.11 → 3.3.13

package/src/superlocalmemory/encoding/graph_builder.py

@@ -142,17 +142,25 @@ class GraphBuilder:
 
     # -- Edge builders (private) -------------------------------------------
 
+    # V3.3.12: Cap entity edges per entity to prevent O(n²) explosion.
+    # With 500+ facts sharing a popular entity, creating an edge to each
+    # produced 44K+ edges and 22-min ingestion. Cap to 20 most recent per entity.
+    _MAX_ENTITY_EDGES_PER_ENTITY: int = 20
+
     def _build_entity_edges(
         self, new_fact: AtomicFact, profile_id: str,
     ) -> list[GraphEdge]:
-        """ENTITY edges: shared canonical entity — NO 50-memory limit."""
+        """ENTITY edges: shared canonical entity — capped to most recent per entity."""
         if not new_fact.canonical_entities:
             return []
         edges: list[GraphEdge] = []
         seen: set[str] = set()
 
         for entity_id in new_fact.canonical_entities:
+            entity_edge_count = 0
             for other in self._db.get_facts_by_entity(entity_id, profile_id):
+                if entity_edge_count >= self._MAX_ENTITY_EDGES_PER_ENTITY:
+                    break
                 if other.fact_id == new_fact.fact_id or other.fact_id in seen:
                     continue
                 if self._edge_exists(new_fact.fact_id, other.fact_id, EdgeType.ENTITY, profile_id):
@@ -163,6 +171,7 @@ class GraphBuilder:
                     target_id=other.fact_id, edge_type=EdgeType.ENTITY,
                     weight=_ENTITY_WEIGHT,
                 ))
+                entity_edge_count += 1
         return edges
 
     def _build_temporal_edges(
@@ -184,7 +193,10 @@ class GraphBuilder:
         seen_pairs: set[tuple[str, str]] = set()
 
         for entity_id in new_fact.canonical_entities:
+            temporal_edge_count = 0
             for other in self._db.get_facts_by_entity(entity_id, profile_id):
+                if temporal_edge_count >= self._MAX_ENTITY_EDGES_PER_ENTITY:
+                    break  # V3.3.12: cap temporal edges like entity edges
                 if other.fact_id == new_fact.fact_id:
                     continue
                 other_dt = _parse_date(other.observation_date)
@@ -212,6 +224,7 @@ class GraphBuilder:
                     target_id=other.fact_id, edge_type=EdgeType.TEMPORAL,
                     weight=weight,
                 ))
+                temporal_edge_count += 1
                 # Reverse: other -> new
                 if not self._edge_exists(other.fact_id, new_fact.fact_id, EdgeType.TEMPORAL, profile_id):
                     edges.append(GraphEdge(
@@ -248,6 +261,9 @@ class GraphBuilder:
                 break
         return edges
 
+    # V3.3.13: Cap causal edges per entity to prevent O(n²) explosion (same as entity/temporal).
+    _MAX_CAUSAL_EDGES_PER_ENTITY: int = 20
+
     def _build_causal_edges(
         self, new_fact: AtomicFact, profile_id: str,
     ) -> list[GraphEdge]:
@@ -260,7 +276,10 @@ class GraphBuilder:
         edges: list[GraphEdge] = []
         seen: set[str] = set()
         for entity_id in new_fact.canonical_entities:
+            causal_edge_count = 0
             for other in self._db.get_facts_by_entity(entity_id, profile_id):
+                if causal_edge_count >= self._MAX_CAUSAL_EDGES_PER_ENTITY:
+                    break
                 if other.fact_id == new_fact.fact_id or other.fact_id in seen:
                     continue
                 if self._edge_exists(other.fact_id, new_fact.fact_id, EdgeType.CAUSAL, profile_id):
@@ -271,6 +290,7 @@ class GraphBuilder:
                     target_id=new_fact.fact_id, edge_type=EdgeType.CAUSAL,
                     weight=_CAUSAL_WEIGHT,
                 ))
+                causal_edge_count += 1
         return edges
 
     # -- Helpers -----------------------------------------------------------

package/src/superlocalmemory/learning/adaptive.py

@@ -31,10 +31,10 @@ _MIN_FEEDBACK_FOR_TRAINING = 20
 
 # Default channel weights (before learning)
 _DEFAULT_WEIGHTS = {
-    "semantic": 1.2,
+    "semantic": 1.5,
     "bm25": 1.0,
     "entity_graph": 1.0,
-    "temporal": 0.8,
+    "temporal": 1.0,
 }
 
 

package/src/superlocalmemory/math/fisher_quantized.py

@@ -145,10 +145,14 @@ class FRQADMetric:
         if bit_width >= 32:
             return np.array(base_variance, dtype=np.float64)
 
-        scale = (32.0 / bit_width) ** self._config.kappa
-        sigma_q = np.asarray(base_variance, dtype=np.float64) * scale
-
-        return np.clip(sigma_q, self._config.variance_floor, self._config.variance_ceiling)
+        # V3.3.12: Paper-correct ADDITIVE variance combination (was multiplicative).
+        # sigma²_total = sigma²_obs + sigma²_quant
+        # sigma²_quant = Delta²/12 where Delta = 2/2^b (uniform quantization step)
+        delta = 2.0 / (2 ** bit_width)  # Quantization step size
+        sigma_q_sq = (delta ** 2) / 12.0  # Uniform quantization noise variance
+        sigma_total = np.asarray(base_variance, dtype=np.float64) + sigma_q_sq
+
+        return np.clip(sigma_total, self._config.variance_floor, self._config.variance_ceiling)
 
     # ------------------------------------------------------------------
     # Core distance (THE novel contribution)

package/src/superlocalmemory/math/langevin.py

@@ -178,6 +178,19 @@ class LangevinDynamics:
         # --- Drift: -lambda^{-2} * grad_U * dt (Eq. 5 term 1) ---
         drift = -(lam_inv ** 2) * grad * self.dt
 
+        # --- V3.3.12: Ebbinghaus forgetting drift (Eq. 6 in Paper 3) ---
+        # λ(m) = 1/S(m) pushes toward boundary (forgetting) based on memory strength.
+        # S(m) is computed from access_count + importance. Higher S → less drift.
+        strength = max(0.5, 0.3 * math.log(1.0 + access_count) + 0.4 * importance)
+        forget_rate = 1.0 / strength  # λ(m)
+        # F(ξ) = ξ/||ξ|| points outward (toward boundary = archived zone)
+        xi_norm = float(np.linalg.norm(xi))
+        if xi_norm > _EPS:
+            forget_direction = xi / xi_norm
+        else:
+            forget_direction = np.zeros(self.dim)
+        forgetting_drift = forget_rate * forget_direction * self.dt * 0.1  # Scaled down to prevent instability
+
         # --- Curvature correction: 0.5 * T * (d-2) * lambda^{-1} * xi * dt (Eq. 5 term 3) ---
         correction = 0.5 * self.temperature * (self.dim - 2) * lam_inv * xi * self.dt
 
@@ -186,8 +199,8 @@ class LangevinDynamics:
         noise = rng.standard_normal(self.dim)
         diffusion = math.sqrt(2.0 * self.temperature * self.dt) * lam_inv * noise
 
-        # --- Full Euler-Maruyama update (Girolami & Calderhead 2011) ---
-        new_xi = xi + drift + correction + diffusion
+        # --- Full Euler-Maruyama update with forgetting (Eq. 6, Girolami & Calderhead 2011) ---
+        new_xi = xi + drift + forgetting_drift + correction + diffusion
 
         # --- Project back into the open ball ---
         new_xi = _project_to_ball(new_xi)

package/src/superlocalmemory/mcp/resources.py

@@ -197,8 +197,8 @@ def register_resources(server, get_engine: Callable) -> None:
 
             # Behavioral patterns summary
             try:
-                from superlocalmemory.learning.behavioral import BehavioralStore
-                store = BehavioralStore(engine._db.db_path)
+                from superlocalmemory.learning.behavioral import BehavioralPatternStore
+                store = BehavioralPatternStore(engine._db.db_path)
                 summary = store.get_summary(pid)
             except Exception:
                 summary = {}

package/src/superlocalmemory/mcp/shared.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3
+
+"""Shared MCP utilities — single source of truth for helpers used
+across tools_core, tools_active, tools_v28, tools_v3, tools_v33.
+
+V3.3.12: Extracted _emit_event to eliminate code duplication.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+_DB_PATH = Path.home() / ".superlocalmemory" / "memory.db"
+
+
+def emit_event(event_type: str, payload: dict | None = None,
+               source_agent: str = "mcp_client") -> None:
+    """Emit an event to the EventBus (best-effort, never raises)."""
+    try:
+        from superlocalmemory.infra.event_bus import EventBus
+        bus = EventBus.get_instance(_DB_PATH)
+        bus.emit(event_type, payload=payload, source_agent=source_agent,
+                 source_protocol="mcp")
+    except Exception:
+        pass

package/src/superlocalmemory/mcp/tools_active.py

@@ -27,7 +27,7 @@ DB_PATH = MEMORY_DIR / "memory.db"
 
 
 def _emit_event(event_type: str, payload: dict | None = None,
-                source_agent: str = "mcp_client") -> None:
+                source_agent: str = "mcp_client") -> None:  # V3.3.12: see also mcp/shared.py
     """Emit an event to the EventBus (best-effort, never raises)."""
     try:
         from superlocalmemory.infra.event_bus import EventBus
@@ -253,3 +253,33 @@ def register_active_tools(server, get_engine: Callable) -> None:
         except Exception as exc:
             logger.exception("report_feedback failed")
             return {"success": False, "error": str(exc)}
+
+    # ------------------------------------------------------------------
+    # close_session — V3.3.12: Expose session closure via MCP
+    # ------------------------------------------------------------------
+
+    @server.tool()
+    async def close_session(session_id: str = "") -> dict:
+        """Close the current session and create temporal summary events.
+
+        Aggregates facts from the session into per-entity temporal summaries,
+        enabling temporal queries like "What happened in session X?"
+
+        Args:
+            session_id: Session to close. Defaults to the most recent session.
+        """
+        try:
+            engine = get_engine()
+            pid = engine.profile_id
+            sid = session_id or getattr(engine, '_last_session_id', '')
+            if not sid:
+                return {"success": False, "error": "No session_id provided"}
+            count = engine.close_session(sid)
+            return {
+                "success": True,
+                "session_id": sid,
+                "summary_events_created": count,
+            }
+        except Exception as exc:
+            logger.exception("close_session failed")
+            return {"success": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_core.py

@@ -139,6 +139,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     "results": result.get("results", []),
                     "count": result.get("result_count", 0),
                     "query_type": result.get("query_type", "unknown"),
+                    "channel_weights": result.get("channel_weights", {}),
+                    "retrieval_time_ms": result.get("retrieval_time_ms", 0),
                 }
             return {"success": False, "error": result.get("error", "Recall failed")}
         except Exception as exc:
@@ -280,11 +282,15 @@ def register_core_tools(server, get_engine: Callable) -> None:
             engine.profile_id = profile_id
 
             # Persist to both config stores so CLI and Dashboard stay in sync
-            from superlocalmemory.server.routes.helpers import (
-                ensure_profile_in_db, set_active_profile_everywhere,
-            )
-            ensure_profile_in_db(profile_id)
-            set_active_profile_everywhere(profile_id)
+            try:
+                from superlocalmemory.server.routes.helpers import (
+                    ensure_profile_in_db, set_active_profile_everywhere,
+                )
+                ensure_profile_in_db(profile_id)
+                set_active_profile_everywhere(profile_id)
+            except ImportError:
+                # Dashboard not installed — profile switch still works for MCP/CLI
+                logger.debug("Dashboard routes not available, profile set in engine only")
 
             return {
                 "success": True,
@@ -337,8 +343,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
         """Get learned behavioral patterns (interests, refinements, archival habits)."""
         try:
             engine = get_engine()
-            from superlocalmemory.learning.behavioral import BehavioralStore
-            store = BehavioralStore(engine._db.db_path)
+            from superlocalmemory.learning.behavioral import BehavioralPatternStore
+            store = BehavioralPatternStore(engine._db.db_path)
             ptype = pattern_type if pattern_type else None
             patterns = store.get_patterns(
                 engine.profile_id, pattern_type=ptype, limit=limit,
@@ -353,8 +359,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
         """Correct or annotate a learned behavioral pattern to improve retrieval."""
         try:
             engine = get_engine()
-            from superlocalmemory.learning.behavioral import BehavioralStore
-            store = BehavioralStore(engine._db.db_path)
+            from superlocalmemory.learning.behavioral import BehavioralPatternStore
+            store = BehavioralPatternStore(engine._db.db_path)
             store.record(
                 engine.profile_id,
                 pattern_type="correction",

package/src/superlocalmemory/mcp/tools_v28.py

@@ -181,8 +181,8 @@ def register_v28_tools(server, get_engine: Callable) -> None:
         """
         try:
             engine = get_engine()
-            from superlocalmemory.learning.behavioral import BehavioralStore
-            store = BehavioralStore(engine._db.db_path)
+            from superlocalmemory.learning.behavioral import BehavioralPatternStore
+            store = BehavioralPatternStore(engine._db.db_path)
             patterns = store.get_patterns(engine.profile_id, limit=limit)
             summary = store.get_summary(engine.profile_id)
             return {

package/src/superlocalmemory/mcp/tools_v3.py

@@ -228,6 +228,7 @@ def register_v3_tools(server, get_engine: Callable) -> None:
 
             facts = engine._db.get_all_facts(pid)[:limit]
             all_contradictions: list[dict] = []
+            errors_count = 0
             for fact in facts:
                 if not fact.embedding or not fact.canonical_entities:
                     continue
@@ -243,11 +244,13 @@ def register_v3_tools(server, get_engine: Callable) -> None:
                             "content_a": fact.content[:80],
                         })
                 except Exception:
+                    errors_count += 1
                     continue
 
             return {
                 "success": True,
                 "facts_checked": len(facts),
+                "facts_errored": errors_count,
                 "contradictions": all_contradictions[:50],
                 "total_contradictions": len(all_contradictions),
             }

package/src/superlocalmemory/mcp/tools_v33.py

@@ -27,7 +27,7 @@ DB_PATH = MEMORY_DIR / "memory.db"
 
 
 def _emit_event(event_type: str, payload: dict | None = None,
-                source_agent: str = "mcp_client") -> None:
+                source_agent: str = "mcp_client") -> None:  # V3.3.12: see also mcp/shared.py
     """Emit an event to the EventBus (best-effort, never raises)."""
     try:
         from superlocalmemory.infra.event_bus import EventBus
@@ -76,8 +76,15 @@ def register_v33_tools(server, get_engine: Callable) -> None:
             )
 
             if dry_run:
-                # Force run (bypass interval) but don't commit
-                result = scheduler.run_decay_cycle(pid, force=True)
+                # Dry run: compute retention stats without applying changes
+                from superlocalmemory.math.ebbinghaus import EbbinghausCurve as _EC
+                facts = engine._db.get_all_facts(pid)
+                zones = {"active": 0, "warm": 0, "cold": 0, "archive": 0, "forgotten": 0}
+                for f in facts:
+                    r = ebbinghaus.compute_retention(f.access_count or 0, f.importance or 0.5, 0, 0.0)
+                    zone = ebbinghaus.classify_zone(r)
+                    zones[zone] = zones.get(zone, 0) + 1
+                result = {"total": len(facts), "transitions": 0, "dry_run_zones": zones}
             else:
                 result = scheduler.run_decay_cycle(pid, force=True)
 
@@ -137,8 +144,9 @@ def register_v33_tools(server, get_engine: Callable) -> None:
             )
 
             if dry_run:
-                # Preview: count what would change without committing
-                result = scheduler.run_eap_cycle(pid)
+                # Dry run: report current quantization state without changes
+                facts = engine._db.get_all_facts(pid)
+                result = {"total": len(facts), "would_quantize": 0, "dry_run": True}
             else:
                 result = scheduler.run_eap_cycle(pid)
 
@@ -185,13 +193,13 @@ def register_v33_tools(server, get_engine: Callable) -> None:
 
             _emit_event("ccq.consolidation_complete", {
                 "profile_id": pid,
-                "clusters_found": result.clusters_found,
+                "clusters_processed": result.clusters_processed,
                 "blocks_created": result.blocks_created,
             })
 
             return {
                 "success": True,
-                "clusters_found": result.clusters_found,
+                "clusters_processed": result.clusters_processed,
                 "blocks_created": result.blocks_created,
                 "facts_archived": result.facts_archived,
                 "compression_ratio": round(result.compression_ratio, 3),
@@ -349,3 +357,56 @@ def register_v33_tools(server, get_engine: Callable) -> None:
         except Exception as exc:
             logger.exception("get_retention_stats tool failed")
             return {"success": False, "error": str(exc)}
+
+    # ------------------------------------------------------------------
+    # 7. run_maintenance — V3.3.12: Combined periodic maintenance cycle
+    # ------------------------------------------------------------------
+    @server.tool()
+    async def run_maintenance(profile_id: str = "") -> dict:
+        """Run all periodic maintenance tasks in a single call.
+
+        Combines Langevin dynamics stepping, Ebbinghaus forgetting decay,
+        and behavioral pattern mining into one convenient maintenance cycle.
+        Clients should call this periodically (e.g., at session end).
+
+        Args:
+            profile_id: Profile to maintain (default: active profile).
+        """
+        try:
+            engine = get_engine()
+            pid = profile_id or engine.profile_id
+            results = {}
+
+            # 1. Langevin dynamics step (lifecycle evolution)
+            try:
+                from superlocalmemory.core.maintenance import run_maintenance as _run_maint
+                maint_result = _run_maint(engine._db, engine._config, pid)
+                results["langevin"] = {"updated": maint_result.get("updated", 0)}
+            except Exception as exc:
+                results["langevin"] = {"error": str(exc)}
+
+            # 2. Ebbinghaus forgetting decay
+            try:
+                from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+                from superlocalmemory.learning.forgetting_scheduler import ForgettingScheduler
+                ebbinghaus = EbbinghausCurve(engine._config.forgetting)
+                scheduler = ForgettingScheduler(engine._db, ebbinghaus, engine._config.forgetting)
+                decay_result = scheduler.run_decay_cycle(pid, force=False)
+                results["forgetting"] = decay_result
+            except Exception as exc:
+                results["forgetting"] = {"error": str(exc)}
+
+            # 3. Behavioral pattern mining
+            try:
+                from superlocalmemory.learning.consolidation_worker import ConsolidationWorker
+                cw = ConsolidationWorker(engine._db, engine._config)
+                patterns = cw._generate_patterns(pid)
+                results["behavioral"] = {"patterns_mined": len(patterns)}
+            except Exception as exc:
+                results["behavioral"] = {"error": str(exc)}
+
+            return {"success": True, "profile": pid, **results}
+
+        except Exception as exc:
+            logger.exception("run_maintenance failed")
+            return {"success": False, "error": str(exc)}

package/src/superlocalmemory/retrieval/agentic.py

@@ -31,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 _MAX_ROUNDS = 2
 _SUFFICIENCY_SCORE_THRESHOLD = 0.6
-_SKIP_TYPES = frozenset()  # Hotpatch: enable agentic for ALL query types including multi_hop
+_SKIP_TYPES = frozenset({"temporal"})  # S15: agentic harms temporal queries
 
 _SUFFICIENCY_SYSTEM = (
     "You evaluate whether retrieved context is sufficient to answer a query. "

package/src/superlocalmemory/retrieval/bm25_channel.py

@@ -68,6 +68,7 @@ class BM25Channel:
         self._corpus: list[list[str]] = []
         self._fact_ids: list[str] = []
         self._fact_id_set: set[str] = set()
+        self._raw_texts: list[str] = []  # V3.3.12: raw content for phrase matching
         self._bm25: BM25Plus | None = None
         self._dirty: bool = False
         self._loaded_profiles: set[str] = set()
@@ -96,15 +97,24 @@ class BM25Channel:
                     self._corpus.append(tokens)
                     self._fact_ids.append(fact.fact_id)
                     self._fact_id_set.add(fact.fact_id)
+                    self._raw_texts.append(fact.content)
                     # Persist for next cold start
                     self._db.store_bm25_tokens(fact.fact_id, profile_id, tokens)
         else:
+            # Load raw texts for phrase matching (V3.3.12)
+            fact_content_map = {}
+            try:
+                facts = self._db.get_all_facts(profile_id)
+                fact_content_map = {f.fact_id: f.content for f in facts}
+            except Exception:
+                pass
             for fid, tokens in token_map.items():
                 if fid in self._fact_id_set:
                     continue
                 self._corpus.append(tokens)
                 self._fact_ids.append(fid)
                 self._fact_id_set.add(fid)
+                self._raw_texts.append(fact_content_map.get(fid, ""))
 
         self._dirty = True
         self._loaded_profiles.add(profile_id)
@@ -128,6 +138,9 @@ class BM25Channel:
         self._corpus.append(tokens)
         self._fact_ids.append(fact_id)
         self._fact_id_set.add(fact_id)
+        if not hasattr(self, '_raw_texts'):
+            self._raw_texts = []
+        self._raw_texts.append(content)
         self._dirty = True
 
         # Persist for cold start
@@ -168,9 +181,16 @@ class BM25Channel:
         scores = self._bm25.get_scores(query_tokens)
 
         scored: list[tuple[str, float]] = []
+        # V3.3.12: Exact phrase bonus — boost facts containing the full query phrase
+        query_lower = query.lower().strip()
         for i, score in enumerate(scores):
             if score > 0.0:
-                scored.append((self._fact_ids[i], float(score)))
+                bonus = score
+                # Exact phrase match bonus: if the query appears as a substring in the document
+                if len(query_lower) >= 5 and i < len(self._raw_texts):
+                    if query_lower in self._raw_texts[i].lower():
+                        bonus *= 1.5  # 50% boost for exact phrase match
+                scored.append((self._fact_ids[i], bonus))
 
         scored.sort(key=lambda x: x[1], reverse=True)
         return scored[:top_k]

package/src/superlocalmemory/retrieval/engine.py

@@ -75,6 +75,8 @@ class RetrievalEngine:
         self._temporal: TemporalChannel | None = channels.get("temporal")
         # Phase G: Hopfield channel (6th)
         self._hopfield: HopfieldChannel | None = channels.get("hopfield")
+        # Phase 3: Spreading Activation channel
+        self._spreading_activation = channels.get("spreading_activation")
         self._embedder = embedder
         self._reranker = reranker
         self._strategy = strategy or QueryStrategyClassifier()
@@ -101,6 +103,11 @@ class RetrievalEngine:
         # Phase G: Hopfield channel (6th) — needs embedding input
         if self._hopfield is not None:
             self._registry.register_channel("hopfield", self._hopfield, needs_embedding=True)
+        # Phase 3: Spreading Activation (5th channel) — needs embedding input
+        if self._spreading_activation is not None:
+            self._registry.register_channel(
+                "spreading_activation", self._spreading_activation, needs_embedding=True,
+            )
 
     def recall(
         self, query: str, profile_id: str,
@@ -139,7 +146,7 @@ class RetrievalEngine:
         fused = weighted_rrf(ch_results, strat.weights, k=self._config.rrf_k)
 
         # Bridge discovery for multi-hop queries
-        if self._bridge is not None and strat.query_type == "multi_hop":
+        if self._bridge is not None and strat.query_type in ("multi_hop", "entity", "factual", "general"):
             try:
                 seed_ids = [fr.fact_id for fr in fused[:10]]
                 bridges = self._bridge.discover(seed_ids, profile_id, max_bridges=10)
@@ -221,6 +228,7 @@ class RetrievalEngine:
         needs_embedding = (
             (self._semantic is not None and "semantic" not in disabled)
             or (self._hopfield is not None and "hopfield" not in disabled)
+            or (self._spreading_activation is not None and "spreading_activation" not in disabled)
         )
         if needs_embedding:
             try:
@@ -269,6 +277,23 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Hopfield channel: %s", exc)
 
+        # Phase 3: Spreading Activation channel (5th) — graph-based associative recall
+        if self._spreading_activation is not None and q_emb is not None and "spreading_activation" not in disabled:
+            try:
+                r = self._spreading_activation.search(q_emb, profile_id, self._config.bm25_top_k)
+                if r:
+                    out["spreading_activation"] = r
+            except Exception as exc:
+                logger.warning("Spreading activation channel: %s", exc)
+
+        # Apply registered post-retrieval filters (forgetting filter, etc.)
+        if hasattr(self, '_registry') and self._registry._filters:
+            for fn in self._registry._filters:
+                try:
+                    out = fn(out, profile_id, None)
+                except Exception as exc:
+                    logger.warning("Post-retrieval filter failed: %s", exc)
+
         return out
 
     # -- Fact loading -------------------------------------------------------
@@ -336,12 +361,24 @@ class RetrievalEngine:
 
         score_map = {fact.fact_id: score for fact, score in scored}
 
+        # Min-max normalize CE scores to [0, 1] within the batch instead of
+        # sigmoid (which compresses the useful discrimination range).
+        ce_values = list(score_map.values())
+        ce_min = min(ce_values) if ce_values else 0.0
+        ce_max = max(ce_values) if ce_values else 1.0
+        ce_range = ce_max - ce_min if ce_max > ce_min else 1.0
+
+        # Also normalize RRF scores so both terms contribute meaningfully
+        rrf_values = [fr.fused_score for fr in fused]
+        rrf_max = max(rrf_values) if rrf_values else 1.0
+        rrf_max = rrf_max if rrf_max > 0 else 1.0
+
         updated = [
             FusionResult(
                 fact_id=fr.fact_id,
                 fused_score=(
-                    alpha * self._sigmoid(score_map.get(fr.fact_id, 0.0))
-                    + (1.0 - alpha) * fr.fused_score
+                    alpha * ((score_map.get(fr.fact_id, ce_min) - ce_min) / ce_range)
+                    + (1.0 - alpha) * (fr.fused_score / rrf_max)
                 ),
                 channel_ranks=fr.channel_ranks,
                 channel_scores=fr.channel_scores,
@@ -425,12 +462,10 @@ class RetrievalEngine:
             # due to BM25 name-matching (greetings like "Hey Caroline!" score high
             # on BM25 but have zero retrieval value)
             content_len = len(fact.content.strip())
-            if content_len < 25:
-                quality = 0.1
-            elif content_len < 50:
-                quality = 0.5
-            elif content_len < 80:
-                quality = 0.8
+            if content_len < 10:
+                quality = 0.3
+            elif content_len < 25:
+                quality = 0.7
             else:
                 quality = 1.0
 

package/src/superlocalmemory/retrieval/entity_channel.py

@@ -67,6 +67,12 @@ def extract_query_entities(query: str) -> list[str]:
         _add(m.group(0))
     for m in re.finditer(r'"([^"]+)"', query):
         _add(m.group(1).strip())
+    # Also extract multi-word capitalized sequences (e.g. "New York", "San Francisco")
+    for m in re.finditer(r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b', query):
+        _add(m.group(1))
+    # Extract all-caps abbreviations (e.g. NYU, MIT, UCLA) — min 2 chars
+    for m in re.finditer(r'\b([A-Z]{2,})\b', query):
+        _add(m.group(1))
 
     return candidates
 

package/src/superlocalmemory/retrieval/fusion.py

@@ -4,7 +4,7 @@
 
 """SuperLocalMemory V3 — Weighted Reciprocal Rank Fusion.
 
-Single-pass RRF with k=60 for diverse retrieval (D116).
+Single-pass RRF with k=15 for sharp rank discrimination on small candidate pools.
 V1 had triple re-fusion which destroyed rankings — fixed in V2.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
@@ -27,7 +27,7 @@ class FusionResult:
 def weighted_rrf(
     channels: dict[str, list[tuple[str, float]]],
     weights: dict[str, float],
-    k: int = 60,
+    k: int = 15,
     max_rank_penalty: int = 1000,
 ) -> list[FusionResult]:
     """Fuse ranked lists via Weighted Reciprocal Rank Fusion.

package/src/superlocalmemory/retrieval/hopfield_channel.py

@@ -288,8 +288,8 @@ class HopfieldChannel:
         ):
             return (self._cached_matrix, self._cached_fact_ids)
 
-        # Step 2: Load all facts
-        facts = self._db.get_all_facts(profile_id)
+        # Step 2: Load facts (V3.3.12: cap to most recent 5000 to bound memory)
+        facts = self._db.get_all_facts(profile_id)[:5000]
         if not facts:
             return (None, [])