superlocalmemory 3.3.11 → 3.3.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.3.11",
+  "version": "3.3.12",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.3.11"
+version = "3.3.12"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}

package/src/superlocalmemory/core/config.py

@@ -86,10 +86,10 @@ class LLMConfig:
 class ChannelWeights:
     """Retrieval channel weights — 5 channels, query-adaptive."""
 
-    # Entity-linked facts are high-precision matches that rank above BM25.
-    semantic: float = 1.2
+    # Semantic should dominate for conversational retrieval (paraphrase matters most).
+    semantic: float = 1.5
     bm25: float = 1.0
-    entity_graph: float = 1.3
+    entity_graph: float = 1.0
     temporal: float = 1.0
     spreading_activation: float = 1.0  # Phase 3: 5th channel (BC-08: default value)
     hopfield: float = 0.8  # Phase G: 6th channel (Hopfield associative memory)
@@ -143,7 +143,7 @@ class RetrievalConfig:
     """Configuration for the retrieval (recall) pipeline."""
 
     # Fusion
-    rrf_k: int = 60               # RRF smoothing constant (D116: k=60 for diversity)
+    rrf_k: int = 15               # RRF smoothing constant (k=15 for candidate pools of 50-200)
     top_k: int = 20               # Final results to return
 
     # Per-channel
@@ -740,6 +740,9 @@ class SLMConfig:
                 retrieval=RetrievalConfig(
                     # V3.3.2: ONNX cross-encoder enabled for all modes (~200MB)
                     use_cross_encoder=True,
+                    # Mode A is zero-LLM: disable agentic retrieval (it replaces
+                    # precision-tuned fusion with crude heuristic expansions)
+                    agentic_max_rounds=0,
                 ),
                 math=MathConfig(
                     sheaf_contradiction_threshold=0.45,  # 768d threshold

package/src/superlocalmemory/core/embeddings.py

@@ -50,7 +50,9 @@ class DimensionMismatchError(RuntimeError):
 
 
 _IDLE_TIMEOUT_SECONDS = 120  # 2 minutes — kill worker after idle
-_SUBPROCESS_RESPONSE_TIMEOUT = 120  # V3.3.2: 120s for ONNX cold start
+# V3.3.12: Configurable via SLM_EMBED_IDLE_TIMEOUT env var (seconds)
+_IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_EMBED_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
+_SUBPROCESS_RESPONSE_TIMEOUT = 180  # V3.3.12: 180s (was 120s) — respawns on stressed systems need more time
 _WORKER_RECYCLE_AFTER = 1000  # Recycle worker after N requests (C++ fragmentation prevention)
 
 

package/src/superlocalmemory/core/engine_wiring.py

@@ -339,7 +339,7 @@ def _init_spreading_activation(
             SpreadingActivation,
             SpreadingActivationConfig,
         )
-        sa_config = SpreadingActivationConfig(enabled=False)
+        sa_config = SpreadingActivationConfig(enabled=True)
         return SpreadingActivation(
             db=db, vector_store=vector_store, config=sa_config,
         )

package/src/superlocalmemory/core/recall_pipeline.py

@@ -192,6 +192,30 @@ def run_recall(
         except Exception as exc:
             logger.debug("Access log batch store failed: %s", exc)
 
+    # V3.3.12: Wire BehavioralTracker.record_query() into live recall pipeline
+    try:
+        from superlocalmemory.learning.behavioral import BehavioralTracker
+        _tracker = BehavioralTracker(db)
+        _tracker.record_query(
+            profile_id=profile_id, query=query,
+            query_type=response.query_type,
+            result_count=len(response.results),
+        )
+    except Exception as exc:
+        logger.debug("Behavioral tracking: %s", exc)
+
+    # V3.3.12: Spaced repetition update on recall (Ebbinghaus on_access_event)
+    if response.results:
+        try:
+            from superlocalmemory.learning.forgetting_scheduler import ForgettingScheduler
+            from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+            _ebbinghaus = EbbinghausCurve(config.forgetting)
+            _fsched = ForgettingScheduler(db, _ebbinghaus, config.forgetting)
+            for r in response.results[:10]:
+                _fsched.on_access_event(r.fact.fact_id, profile_id)
+        except Exception as exc:
+            logger.debug("Spaced repetition update: %s", exc)
+
     # Phase 3: Hebbian strengthening for co-accessed facts
     if auto_linker and response.results:
         try:

package/src/superlocalmemory/core/recall_worker.py

@@ -187,10 +187,28 @@ def _handle_update_memory(fact_id: str, content: str, agent_id: str = "system")
     if not rows:
         return {"ok": False, "error": f"Memory {fact_id} not found"}
     old_content = dict(rows[0]).get("content", "")[:80]
-    engine._db.execute(
-        "UPDATE atomic_facts SET content = ? WHERE fact_id = ?",
-        (content, fact_id),
-    )
+    # V3.3.12: Re-embed updated content so semantic search + BM25 stay consistent.
+    # Previously only the text column was updated, leaving stale embeddings.
+    updates: dict = {"content": content}
+    if engine._embedder:
+        try:
+            new_emb = engine._embedder.embed(content)
+            if new_emb:
+                updates["embedding"] = new_emb
+                fm, fv = engine._embedder.compute_fisher_params(new_emb)
+                updates["fisher_mean"] = fm
+                updates["fisher_variance"] = fv
+        except Exception:
+            pass
+    engine._db.update_fact(fact_id, updates)
+    # Update BM25 index for the new content
+    if hasattr(engine, '_retrieval_engine') and engine._retrieval_engine:
+        bm25 = getattr(engine._retrieval_engine, '_bm25', None)
+        if bm25:
+            try:
+                bm25.add(fact_id, content, pid)
+            except Exception:
+                pass
     import logging as _logging
     _logging.getLogger("superlocalmemory.audit").info(
         "UPDATE fact_id=%s by agent=%s old=%s new=%s",

package/src/superlocalmemory/core/reranker_worker.py

@@ -0,0 +1,220 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Subprocess reranker worker — isolates PyTorch/ONNX from main process.
+
+Same pattern as embedding_worker.py. The main process stays at ~60 MB.
+All cross-encoder model memory lives in this worker subprocess.
+
+Protocol (JSON over stdin/stdout):
+  Request:  {"cmd": "rerank", "query": "...", "documents": ["...", ...]}
+  Response: {"ok": true, "scores": [0.95, 0.32, ...]}
+
+  Request:  {"cmd": "score", "query": "...", "document": "..."}
+  Response: {"ok": true, "score": 0.87}
+
+  Request:  {"cmd": "ping"}
+  Response: {"ok": true, "backend": "onnx", "model": "..."}
+
+  Request:  {"cmd": "quit"}
+  (worker exits)
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import signal
+import struct
+import sys
+import threading
+
+# Force CPU BEFORE any torch import
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["PYTORCH_MPS_HIGH_WATERMARK_RATIO"] = "0.0"
+os.environ["PYTORCH_MPS_MEM_LIMIT"] = "0"
+os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["TORCH_DEVICE"] = "cpu"
+
+# SIGTERM bridge for Docker/systemd
+if sys.platform != "win32":
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+
+
+def _start_parent_watchdog() -> None:
+    """Monitor parent process — self-terminate if parent dies.
+
+    Prevents orphaned workers that consume 1+ GB each when the parent
+    process crashes, is killed, or exits without cleanup.
+
+    V3.3.7: Added after incident where ~30 orphaned workers consumed 33 GB.
+    """
+    parent_pid = os.getppid()
+
+    def _watch() -> None:
+        import time
+        while True:
+            time.sleep(5)
+            try:
+                os.kill(parent_pid, 0)  # Check if parent is alive (signal 0)
+            except OSError:
+                # Parent is dead — self-terminate
+                os._exit(0)
+
+    t = threading.Thread(target=_watch, daemon=True, name="parent-watchdog")
+    t.start()
+
+
+def _detect_onnx_variant() -> str:
+    """Auto-detect the best ONNX model variant for the current platform."""
+    arch = platform.machine().lower()
+    is_64bit = struct.calcsize("P") * 8 == 64
+
+    if sys.platform == "darwin" and arch in ("arm64", "aarch64"):
+        return "onnx/model_qint8_arm64.onnx"
+    if arch in ("x86_64", "amd64") and is_64bit:
+        return "onnx/model_quint8_avx2.onnx"
+    return "onnx/model.onnx"
+
+
+def _worker_main() -> None:
+    """Main loop: read JSON requests from stdin, write responses to stdout."""
+    _start_parent_watchdog()  # V3.3.7: self-terminate if parent dies
+
+    model = None
+    active_backend = ""
+    model_name = ""
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            _respond({"ok": False, "error": "Invalid JSON"})
+            continue
+
+        cmd = req.get("cmd", "")
+
+        if cmd == "quit":
+            break
+
+        if cmd == "ping":
+            _respond({
+                "ok": True,
+                "loaded": model is not None,
+                "backend": active_backend,
+                "model": model_name,
+            })
+            continue
+
+        if cmd == "load":
+            name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-6-v2")
+            backend = req.get("backend", "onnx")
+            model, active_backend, model_name = _load_model(name, backend)
+            _respond({
+                "ok": model is not None,
+                "backend": active_backend,
+                "model": model_name,
+            })
+            continue
+
+        if cmd == "rerank":
+            query = req.get("query", "")
+            documents = req.get("documents", [])
+            if not query or not documents:
+                _respond({"ok": False, "error": "Missing query or documents"})
+                continue
+            if model is None:
+                # Auto-load with defaults
+                name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-6-v2")
+                backend = req.get("backend", "onnx")
+                model, active_backend, model_name = _load_model(name, backend)
+            if model is None:
+                _respond({"ok": False, "error": "Model load failed"})
+                continue
+            try:
+                pairs = [(query, doc) for doc in documents]
+                try:
+                    import torch
+                    with torch.inference_mode():
+                        scores = model.predict(pairs)
+                except ImportError:
+                    scores = model.predict(pairs)
+                _respond({
+                    "ok": True,
+                    "scores": [float(s) for s in scores],
+                })
+            except Exception as exc:
+                _respond({"ok": False, "error": str(exc)})
+            continue
+
+        if cmd == "score":
+            query = req.get("query", "")
+            document = req.get("document", "")
+            if not query or not document:
+                _respond({"ok": False, "error": "Missing query or document"})
+                continue
+            if model is None:
+                name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-6-v2")
+                backend = req.get("backend", "onnx")
+                model, active_backend, model_name = _load_model(name, backend)
+            if model is None:
+                _respond({"ok": False, "error": "Model load failed"})
+                continue
+            try:
+                try:
+                    import torch
+                    with torch.inference_mode():
+                        scores = model.predict([(query, document)])
+                except ImportError:
+                    scores = model.predict([(query, document)])
+                _respond({"ok": True, "score": float(scores[0])})
+            except Exception as exc:
+                _respond({"ok": False, "error": str(exc)})
+            continue
+
+        _respond({"ok": False, "error": f"Unknown command: {cmd}"})
+
+
+def _load_model(
+    name: str, backend: str,
+) -> tuple:
+    """Load cross-encoder model. Returns (model, backend_name, model_name)."""
+    try:
+        from sentence_transformers import CrossEncoder
+
+        if backend == "onnx":
+            try:
+                onnx_file = _detect_onnx_variant()
+                m = CrossEncoder(
+                    name, backend="onnx",
+                    model_kwargs={"file_name": onnx_file},
+                )
+                return m, "onnx", name
+            except Exception:
+                # ONNX failed → try PyTorch
+                pass
+        # PyTorch fallback (or explicit pytorch backend)
+        m = CrossEncoder(name)
+        return m, "pytorch", name
+    except ImportError:
+        return None, "", ""
+    except Exception:
+        return None, "", ""
+
+
+def _respond(data: dict) -> None:
+    """Write JSON response to stdout, flush immediately."""
+    sys.stdout.write(json.dumps(data) + "\n")
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    _worker_main()

package/src/superlocalmemory/core/store_pipeline.py

@@ -170,13 +170,23 @@ def run_store(
     # V3.3.11: Also store raw content as a verbatim fact to preserve details
     # that fact extraction may abstract away (dates, names, specifics).
     # This ensures BM25 and semantic search can always find the original text.
+    # V3.3.12: Extract entities from verbatim content so entity channel + temporal
+    # channel can find it (was entities=[] which made 4/6 channels blind).
     if content.strip() and len(content.strip()) >= 20:
         import uuid
+        import re as _re
+        _verbatim_text = content.strip()
+        # Extract entities using the same regex as fact_extractor
+        _ent_re = _re.compile(r"\b([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})\b")
+        _entity_set = {m.group(1) for m in _ent_re.finditer(_verbatim_text)}
+        # Also extract all-caps abbreviations (NYU, MIT, etc.) — dedup with first set
+        _entity_set |= {m.group(1) for m in _re.finditer(r'\b([A-Z]{2,})\b', _verbatim_text)}
+        _verbatim_entities = sorted(_entity_set)
         verbatim = AtomicFact(
             fact_id=uuid.uuid4().hex[:16],
-            content=content.strip(),
+            content=_verbatim_text,
             fact_type=FactType.EPISODIC,
-            entities=[],
+            entities=_verbatim_entities,
             session_id=session_id,
             observation_date=parsed_date,
             confidence=0.9,

package/src/superlocalmemory/encoding/fact_extractor.py

@@ -84,7 +84,8 @@ _INTERVAL_RE = re.compile(
 )
 
 _ENTITY_RE = re.compile(
-    r"\b([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})\b"  # Capitalized word sequences
+    r"\b([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})\b"    # Capitalized word sequences
+    r"|\b([A-Z]{2,})\b"                              # ALL-CAPS abbreviations (NYU, MIT)
 )
 
 _QUOTED_RE = re.compile(r'"([^"]+)"')  # Quoted strings as entities
@@ -243,7 +244,7 @@ def _extract_entities(text: str) -> list[str]:
 
     # Capitalized word sequences (proper nouns)
     for match in _ENTITY_RE.finditer(text):
-        candidate = match.group(1).strip()
+        candidate = (match.group(1) or match.group(2) or "").strip()
         # Filter common English words that start sentences
         # Check first word of multi-word candidates against stop list
         _first_word = candidate.split()[0].lower() if candidate else ""
@@ -495,10 +496,17 @@ class FactExtractor:
     ) -> list[AtomicFact]:
         """Rule-based extraction: regex entities, keyword classification, scoring."""
         combined = "\n".join(turns)
-        sentences = _split_sentences(combined)
-        if not sentences:
-            # If no proper sentences, treat each turn as a sentence
-            sentences = [t.strip() for t in turns if len(t.strip()) >= 8]
+        raw_sentences = _split_sentences(combined)
+        if not raw_sentences:
+            raw_sentences = [t.strip() for t in turns if len(t.strip()) >= 8]
+
+        # V3.3.12: Sliding window of 2 sentences to preserve cross-sentence context.
+        # "She enrolled at NYU. Starting January 2024." → becomes one combined fact.
+        sentences = list(raw_sentences)  # Keep originals
+        for i in range(len(raw_sentences) - 1):
+            pair = raw_sentences[i].rstrip() + " " + raw_sentences[i + 1].lstrip()
+            if len(pair) <= 300:  # Only combine if not too long
+                sentences.append(pair)
 
         # Build entity frequency map for importance scoring
         entity_freq: dict[str, int] = {}
@@ -549,8 +557,8 @@ class FactExtractor:
             if importance < self._config.min_fact_confidence:
                 continue
 
-            # Determine speaker from turn position heuristic
-            speaker = self._infer_speaker(normalized, turns, speaker_a, speaker_b)
+            # V3.3.12: Speaker inference removed — result was never stored in AtomicFact.
+            # The speaker info is preserved in verbatim facts via [Speaker]: prefix.
 
             facts.append(AtomicFact(
                 fact_id=_new_id(),

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(

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, [])
 

package/src/superlocalmemory/retrieval/reranker.py

@@ -35,7 +35,9 @@ _live_rerankers: set[weakref.ref] = set()
 logger = logging.getLogger(__name__)
 
 _IDLE_TIMEOUT_SECONDS = 120  # 2 min → kill worker
-_SUBPROCESS_RESPONSE_TIMEOUT = 120  # 120s for ONNX cold start
+# V3.3.12: Configurable via SLM_RERANKER_IDLE_TIMEOUT env var
+_IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_RERANKER_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
+_SUBPROCESS_RESPONSE_TIMEOUT = 180  # V3.3.12: 180s (was 120s) for stressed system respawns
 _WORKER_RECYCLE_AFTER = 500  # Recycle after N requests
 
 
@@ -129,8 +131,23 @@ class CrossEncoderReranker:
             finally:
                 self._worker_loading = False
 
-        t = threading.Thread(target=_warmup, daemon=True, name="ce-warmup")
-        t.start()
+        self._warmup_thread = threading.Thread(target=_warmup, daemon=True, name="ce-warmup")
+        self._warmup_thread.start()
+
+    def warmup_sync(self, timeout: float = 120.0) -> bool:
+        """Block until reranker model is loaded. Returns True if ready.
+
+        V3.3.12: Critical for benchmarks and first-recall quality.
+        Without this, first 30-60s of recalls get no reranking (-30.7pp).
+        """
+        if self._model_loaded:
+            return True
+        if not self._worker_loading and not self._model_loaded:
+            self._start_background_warmup()
+        t = getattr(self, '_warmup_thread', None)
+        if t is not None:
+            t.join(timeout=timeout)
+        return self._model_loaded
 
     # ------------------------------------------------------------------
     # Worker management (mirrors EmbeddingService pattern)
@@ -304,13 +321,13 @@ class CrossEncoderReranker:
 
         documents = [fact.content for fact, _ in candidates]
 
-        # Short timeout (10s) — model should already be loaded by warmup.
-        # If worker crashed or is still loading, fallback immediately.
+        # V3.3.12: Increased timeout 10s→60s — L-12-v2 needs PyTorch + ONNX load.
+        # Critical: Paper 2 ablation showed -30.7pp without reranking.
         resp = self._send_request({
             "cmd": "rerank",
             "query": query,
             "documents": documents,
-        }, timeout=10.0)
+        }, timeout=60.0)
 
         if resp is None or not resp.get("ok"):
             # Fallback: return by existing score

package/src/superlocalmemory/retrieval/semantic_channel.py

@@ -182,7 +182,7 @@ class SemanticChannel:
             else:
                 sim = cos_sim
 
-            if sim > 0.3:
+            if sim > 0.05:
                 scored.append((fact.fact_id, sim))
 
         scored.sort(key=lambda x: x[1], reverse=True)
@@ -235,7 +235,7 @@ class SemanticChannel:
             else:
                 sim = cos_sim
 
-            if sim > 0.3:
+            if sim > 0.05:
                 scored.append((fact.fact_id, sim))
 
         scored.sort(key=lambda x: x[1], reverse=True)

package/src/superlocalmemory/retrieval/temporal_channel.py

@@ -124,6 +124,16 @@ class TemporalChannel:
         import re
         _PROPER_RE = re.compile(r"\b([A-Z][a-z]+)\b")
         names = [m.group(1) for m in _PROPER_RE.finditer(query)]
+        # Also try title-cased version for lowercase queries
+        if not names:
+            names = [m.group(1) for m in _PROPER_RE.finditer(query.title())]
+        # Filter out common words from title-casing
+        _stop = {"What", "When", "Where", "Who", "Which", "How", "Does", "Did",
+                 "The", "That", "This", "There", "Then", "Have", "Has", "Had",
+                 "About", "After", "Before", "From", "With", "Would", "Could",
+                 "Should", "Will", "Because", "Also", "Just", "Like", "Know",
+                 "Think", "Tell", "Said"}
+        names = [n for n in names if n not in _stop]
         if not names:
             return []
 
@@ -146,7 +156,10 @@ class TemporalChannel:
                 fid = dict(row)["fact_id"]
                 if fid not in seen:
                     seen.add(fid)
-                    results.append((fid, 0.85))  # High base score for entity-temporal
+                    # Rank by position (first events more likely relevant) instead
+                    # of flat 0.85 which loses discrimination
+                    rank_score = 0.85 - len(seen) * 0.02
+                    results.append((fid, max(0.3, rank_score)))
 
         return results
 

package/src/superlocalmemory/storage/schema.py

@@ -442,6 +442,8 @@ CREATE INDEX IF NOT EXISTS idx_edges_target
     ON graph_edges (profile_id, target_id);
 CREATE INDEX IF NOT EXISTS idx_edges_type
     ON graph_edges (profile_id, edge_type);
+CREATE INDEX IF NOT EXISTS idx_edges_exists_check
+    ON graph_edges (profile_id, source_id, target_id, edge_type);
 """