superlocalmemory 3.3.15 → 3.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.3.15",
+  "version": "3.3.17",
   "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.15"
+version = "3.3.17"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}

package/src/superlocalmemory/core/embedding_worker.py

@@ -144,6 +144,16 @@ def _worker_main() -> None:
                 _respond({"ok": True, "vectors": result, "dim": dim})
             except Exception as exc:
                 _respond({"ok": False, "error": str(exc)})
+
+            # V3.3.16: RSS watchdog — self-terminate if memory exceeds 1.5GB.
+            # PyTorch on ARM64 Mac never returns memory to OS. After ~200 embeds
+            # a worker that started at 300MB grows to 17GB+. Parent auto-respawns
+            # a fresh worker on next request (existing mechanism in embeddings.py).
+            import resource
+            rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 / 1024
+            if rss_mb > 2500:
+                sys.exit(0)
+
             continue
 
         _respond({"ok": False, "error": f"Unknown command: {cmd}"})

package/src/superlocalmemory/core/embeddings.py

@@ -207,11 +207,29 @@ class EmbeddingService:
                 return resp["vectors"]
             except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
                 logger.warning(
-                    "Embedding worker communication failed: %s. "
-                    "Run 'slm doctor' to check dependencies and Python version.",
+                    "Embedding worker communication failed: %s — respawning.",
                     exc,
                 )
                 self._kill_worker()
+                # V3.3.16: Auto-retry once after worker death (RSS watchdog
+                # or crash). Respawn + re-send instead of returning None.
+                try:
+                    self._ensure_worker()
+                    if self._worker_proc is not None:
+                        self._worker_proc.stdin.write(req)
+                        self._worker_proc.stdin.flush()
+                        resp_line = self._readline_with_timeout(
+                            self._worker_proc.stdout,
+                            _SUBPROCESS_RESPONSE_TIMEOUT,
+                        )
+                        if resp_line:
+                            resp = json.loads(resp_line)
+                            if resp.get("ok"):
+                                self._reset_idle_timer()
+                                self._request_count = 1
+                                return resp["vectors"]
+                except Exception:
+                    self._kill_worker()
                 return None
 
     @staticmethod

package/src/superlocalmemory/core/recall_pipeline.py

@@ -24,6 +24,36 @@ from superlocalmemory.storage.models import Mode, RecallResponse
 logger = logging.getLogger(__name__)
 
 
+# ---------------------------------------------------------------------------
+# V3.3.16: Module-level singletons for recall hot-path objects.
+# Prevents creating new BehavioralTracker / ForgettingScheduler per recall
+# (304 recalls = 304 objects that fragment pymalloc arenas → 25GB).
+# ---------------------------------------------------------------------------
+
+_behavioral_tracker_cache: dict[int, object] = {}
+_forgetting_scheduler_cache: dict[int, object] = {}
+
+
+def _get_behavioral_tracker(db: Any) -> Any:
+    """Get or create a cached BehavioralTracker for this DB instance."""
+    key = id(db)
+    if key not in _behavioral_tracker_cache:
+        from superlocalmemory.learning.behavioral import BehavioralTracker
+        _behavioral_tracker_cache[key] = BehavioralTracker(db)
+    return _behavioral_tracker_cache[key]
+
+
+def _get_forgetting_scheduler(db: Any, config: Any) -> Any:
+    """Get or create a cached ForgettingScheduler for this DB instance."""
+    key = id(db)
+    if key not in _forgetting_scheduler_cache:
+        from superlocalmemory.learning.forgetting_scheduler import ForgettingScheduler
+        from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+        ebbinghaus = EbbinghausCurve(config.forgetting)
+        _forgetting_scheduler_cache[key] = ForgettingScheduler(db, ebbinghaus, config.forgetting)
+    return _forgetting_scheduler_cache[key]
+
+
 # ---------------------------------------------------------------------------
 # apply_adaptive_ranking  (was MemoryEngine._apply_adaptive_ranking)
 # ---------------------------------------------------------------------------
@@ -192,11 +222,11 @@ 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
+    # V3.3.16: Behavioral tracking + spaced repetition use module-level
+    # singletons to avoid creating new objects per recall (was causing
+    # object accumulation across 304 benchmark recalls).
     try:
-        from superlocalmemory.learning.behavioral import BehavioralTracker
-        _tracker = BehavioralTracker(db)
-        _tracker.record_query(
+        _get_behavioral_tracker(db).record_query(
             profile_id=profile_id, query=query,
             query_type=response.query_type,
             result_count=len(response.results),
@@ -204,15 +234,11 @@ def run_recall(
     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)
+            fsched = _get_forgetting_scheduler(db, config)
             for r in response.results[:10]:
-                _fsched.on_access_event(r.fact.fact_id, profile_id)
+                fsched.on_access_event(r.fact.fact_id, profile_id)
         except Exception as exc:
             logger.debug("Spaced repetition update: %s", exc)
 
@@ -237,30 +263,31 @@ def run_recall(
         for r in response.results:
             trust_scorer.update_on_access("fact", r.fact.fact_id, profile_id)
 
-    # Fisher Bayesian update on recall
-    q_emb = embedder.embed(query) if embedder else None
+    # Fisher Bayesian update on recall — narrows variance on accessed facts
+    # so they score higher on subsequent recalls (critical for benchmark: +24pp).
+    # V3.3.16: Reuse query embedding from retrieval engine cache instead of
+    # calling embedder.embed() again (which was the memory leak source).
     q_var_arr = None
-    if embedder and q_emb:
-        _, q_var_list = embedder.compute_fisher_params(q_emb)
-        import numpy as _np
-        q_var_arr = _np.array(q_var_list, dtype=_np.float64)
+    if embedder and hasattr(retrieval_engine, '_query_embedding_cache'):
+        cached_emb = retrieval_engine._query_embedding_cache.get(query)
+        if cached_emb is not None:
+            import numpy as _np
+            _, q_var_list = embedder.compute_fisher_params(cached_emb)
+            q_var_arr = _np.array(q_var_list, dtype=_np.float64)
 
     for r in response.results:
         updates: dict[str, object] = {
             "access_count": r.fact.access_count + 1,
         }
-        # Bayesian variance narrowing after 3+ accesses
         if (q_var_arr is not None
                 and r.fact.fisher_variance
                 and len(r.fact.fisher_variance) == len(q_var_arr)
                 and r.fact.access_count >= 3):
             import numpy as _np
             f_var = _np.array(r.fact.fisher_variance, dtype=_np.float64)
-            # Conjugate Gaussian update: 1/new_var = 1/f_var + 1/q_var
             new_var = 1.0 / (1.0 / _np.maximum(f_var, 0.05) + 1.0 / _np.maximum(q_var_arr, 0.05))
             new_var = _np.clip(new_var, 0.05, 2.0)
             updates["fisher_variance"] = new_var.tolist()
-
         db.update_fact(r.fact.fact_id, updates)
 
     # Post-operation hooks (audit, trust signal, learning)

package/src/superlocalmemory/core/recall_worker.py

@@ -321,6 +321,13 @@ def _worker_main() -> None:
         except Exception as exc:
             _respond({"ok": False, "error": str(exc)})
 
+        # V3.3.16: RSS watchdog — self-terminate if memory exceeds 1.5GB.
+        # Parent auto-respawns a fresh worker on next request.
+        import resource
+        rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 / 1024
+        if rss_mb > 2500:
+            sys.exit(0)
+
 
 def _respond(data: dict) -> None:
     sys.stdout.write(json.dumps(data) + "\n")
@@ -328,4 +335,7 @@ def _respond(data: dict) -> None:
 
 
 if __name__ == "__main__":
-    _worker_main()
+    try:
+        _worker_main()
+    except KeyboardInterrupt:
+        sys.exit(0)

package/src/superlocalmemory/core/reranker_worker.py

@@ -118,10 +118,33 @@ def _worker_main() -> None:
             name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-12-v2")
             backend = req.get("backend", "onnx")
             model, active_backend, model_name = _load_model(name, backend)
+            # V3.3.16: Run real inference to trigger ONNX CoreML JIT compilation.
+            # Without this, first real rerank call triggers 30-60s compilation
+            # that exceeds the caller's timeout, killing the worker.
+            warmup_ok = False
+            if model is not None:
+                try:
+                    # Use 60 pairs (realistic batch size) to trigger CoreML
+                    # compilation for the actual workload. 3 pairs compiled a
+                    # different execution plan that got recompiled on 60 pairs.
+                    dummy_pairs = [
+                        (f"What happened to person {i}?", f"Person {i} went to location {i} and did activity {i} last summer with friends.")
+                        for i in range(60)
+                    ]
+                    try:
+                        import torch
+                        with torch.inference_mode():
+                            _scores = model.predict(dummy_pairs)
+                    except ImportError:
+                        _scores = model.predict(dummy_pairs)
+                    warmup_ok = True
+                except Exception:
+                    pass
             _respond({
                 "ok": model is not None,
                 "backend": active_backend,
                 "model": model_name,
+                "warmup_inference": warmup_ok,
             })
             continue
 
@@ -153,6 +176,13 @@ def _worker_main() -> None:
                 })
             except Exception as exc:
                 _respond({"ok": False, "error": str(exc)})
+
+            # V3.3.16: RSS watchdog — same as embedding_worker
+            import resource
+            rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 / 1024
+            if rss_mb > 2500:
+                sys.exit(0)
+
             continue
 
         if cmd == "score":

package/src/superlocalmemory/retrieval/engine.py

@@ -338,31 +338,27 @@ class RetrievalEngine:
         if not candidates:
             return fused
 
-        # Bug 3 fix: strip speaker tags from content before CE scoring
-        clean_candidates: list[tuple[AtomicFact, float]] = []
-        for fact, score in candidates:
-            cleaned_content = re.sub(r'^\[[A-Za-z]+\]:\s*', '', fact.content)
-            clean_fact = AtomicFact(
-                fact_id=fact.fact_id, memory_id=fact.memory_id,
-                profile_id=fact.profile_id, content=cleaned_content,
-                fact_type=fact.fact_type, entities=fact.entities,
-                canonical_entities=fact.canonical_entities,
-                observation_date=fact.observation_date,
-                referenced_date=fact.referenced_date,
-                confidence=fact.confidence, importance=fact.importance,
-                evidence_count=fact.evidence_count,
-                access_count=fact.access_count,
-                embedding=fact.embedding, created_at=fact.created_at,
-            )
-            clean_candidates.append((clean_fact, score))
+        # V3.3.16: Strip speaker tags WITHOUT copying full AtomicFact objects.
+        # Previously created full copies including 768-dim embeddings (~6KB each),
+        # which over 304 recalls caused pymalloc arena fragmentation → 25GB.
+        # Now: temporarily patch .content on originals, rerank, then restore.
+        originals: list[tuple[AtomicFact, str]] = []  # (fact, original_content)
+        for fact, _ in candidates:
+            orig = fact.content
+            fact.content = re.sub(r'^\[[A-Za-z]+\]:\s*', '', orig)
+            originals.append((fact, orig))
 
         try:
             scored = self._reranker.rerank(  # type: ignore[union-attr]
-                query, clean_candidates, top_k=len(clean_candidates),
+                query, candidates, top_k=len(candidates),
             )
         except Exception as exc:
             logger.warning("Cross-encoder rerank failed: %s", exc)
             return fused
+        finally:
+            # Restore original content (with speaker tags)
+            for fact, orig_content in originals:
+                fact.content = orig_content
 
         score_map = {fact.fact_id: score for fact, score in scored}
 

package/src/superlocalmemory/retrieval/reranker.py

@@ -94,8 +94,10 @@ class CrossEncoderReranker:
     def _start_background_warmup(self) -> None:
         """Start worker and load model in background thread.
 
-        Returns immediately. The worker loads the model in parallel
-        with the rest of engine initialization and the first recall.
+        V3.3.16: Uses _send_request (lock-protected) instead of raw
+        stdin/stdout access. Previous code wrote to stdin without the
+        lock, creating a race where the warmup's readline thread could
+        steal responses meant for _send_request → deadlock → timeout.
         """
         if self._worker_loading or self._model_loaded:
             return
@@ -106,26 +108,18 @@ class CrossEncoderReranker:
                 self._ensure_worker()
                 if self._worker_proc is None:
                     return
-                # Send load command and wait for response
-                req = json.dumps({
+                resp = self._send_request({
                     "cmd": "load",
                     "model_name": self._model_name,
                     "backend": self._backend,
-                }) + "\n"
-                self._worker_proc.stdin.write(req)
-                self._worker_proc.stdin.flush()
-                resp_line = self._readline_with_timeout(
-                    self._worker_proc.stdout, _SUBPROCESS_RESPONSE_TIMEOUT,
-                )
-                if resp_line:
-                    resp = json.loads(resp_line)
-                    if resp.get("ok"):
-                        self._model_loaded = True
-                        logger.info(
-                            "Reranker worker warm (backend=%s)",
-                            resp.get("backend", "?"),
-                        )
-                        self._reset_idle_timer()
+                }, timeout=_SUBPROCESS_RESPONSE_TIMEOUT)
+                if resp and resp.get("ok"):
+                    self._model_loaded = True
+                    logger.info(
+                        "Reranker worker warm (backend=%s, warmup_inference=%s)",
+                        resp.get("backend", "?"),
+                        resp.get("warmup_inference", False),
+                    )
             except Exception as exc:
                 logger.debug("Background reranker warmup failed: %s", exc)
             finally:
@@ -321,13 +315,14 @@ class CrossEncoderReranker:
 
         documents = [fact.content for fact, _ in candidates]
 
-        # V3.3.12: Increased timeout 10s→60s — L-12-v2 needs PyTorch + ONNX load.
-        # Critical: Paper 2 ablation showed -30.7pp without reranking.
+        # V3.3.16: Timeout 180s — ONNX CoreML compilation can take 30-60s on
+        # first inference even after model load. The warmup_inference in the
+        # worker should prevent this, but 180s is a safety net.
         resp = self._send_request({
             "cmd": "rerank",
             "query": query,
             "documents": documents,
-        }, timeout=60.0)
+        }, timeout=180.0)
 
         if resp is None or not resp.get("ok"):
             # Fallback: return by existing score