superlocalmemory 3.3.16 → 3.3.18

package/package.json

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

package/src/superlocalmemory/core/config.py

@@ -155,7 +155,7 @@ class RetrievalConfig:
     # Reranking (V3.3.2: ONNX backend enabled for all modes)
     use_cross_encoder: bool = True
     cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-12-v2"
-    cross_encoder_backend: str = "onnx"  # "onnx" (~200MB) or "" (PyTorch, ~1.5GB)
+    cross_encoder_backend: str = ""  # "" = PyTorch (~500MB stable), "onnx" = ONNX (leaks on ARM64 CoreML)
 
     # Agentic (Mode C only)
     agentic_max_rounds: int = 3

package/src/superlocalmemory/core/embedding_worker.py

@@ -35,6 +35,8 @@ os.environ["PYTORCH_MPS_MEM_LIMIT"] = "0"
 os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 os.environ["TORCH_DEVICE"] = "cpu"
+# V3.3.17: Disable CoreML EP for ONNX Runtime — uses 3-5GB on ARM64 Mac.
+os.environ["ORT_DISABLE_COREML"] = "1"
 
 # SIGTERM bridge: Docker/systemd send SIGTERM to stop processes.
 # Without this, the worker ignores SIGTERM and becomes a zombie.
@@ -65,6 +67,34 @@ def _start_parent_watchdog() -> None:
     t.start()
 
 
+def _load_embedding_model(name: str) -> tuple:
+    """Load embedding model. ONNX first (no memory leak), PyTorch fallback.
+
+    V3.3.17: PyTorch SentenceTransformer on ARM64 Mac leaks memory —
+    grows from 300MB to 17GB after ~200 encode calls. ONNX Runtime
+    has no such issue. Same approach as CrossEncoder ONNX migration.
+
+    Returns (model, backend_name) or (None, "").
+    """
+    from sentence_transformers import SentenceTransformer
+
+    # Tier 1: ONNX (stable memory, ~200MB footprint)
+    try:
+        m = SentenceTransformer(name, backend="onnx", trust_remote_code=True)
+        return m, "onnx"
+    except Exception:
+        pass
+
+    # Tier 2: PyTorch CPU (stable at ~1.4GB after 100+ calls, verified)
+    try:
+        import torch
+        with torch.inference_mode():
+            m = SentenceTransformer(name, trust_remote_code=True, device="cpu")
+        return m, "pytorch"
+    except Exception:
+        return None, ""
+
+
 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
@@ -97,18 +127,17 @@ def _worker_main() -> None:
         if cmd == "load":
             name = req.get("model_name", "nomic-ai/nomic-embed-text-v1.5")
             expected_dim = req.get("dimension", 768)
-            try:
-                from sentence_transformers import SentenceTransformer
-                model = SentenceTransformer(name, trust_remote_code=True, device="cpu")
+            model, active_backend = _load_embedding_model(name)
+            if model is not None:
                 dim = model.get_sentence_embedding_dimension()
                 if dim != expected_dim:
                     _respond({"ok": False, "error": f"Dimension mismatch: {dim} != {expected_dim}"})
                     model = None
                     continue
                 model_name = name
-                _respond({"ok": True, "dim": dim, "model": name})
-            except Exception as exc:
-                _respond({"ok": False, "error": str(exc)})
+                _respond({"ok": True, "dim": dim, "model": name, "backend": active_backend})
+            else:
+                _respond({"ok": False, "error": "Model load failed"})
             continue
 
         if cmd == "embed":
@@ -117,26 +146,16 @@ def _worker_main() -> None:
                 _respond({"ok": False, "error": "No texts provided"})
                 continue
             if model is None:
-                # Auto-load if not yet loaded
                 name = req.get("model_name", "nomic-ai/nomic-embed-text-v1.5")
-                expected_dim = req.get("dimension", 768)
-                try:
-                    from sentence_transformers import SentenceTransformer
-                    model = SentenceTransformer(name, trust_remote_code=True, device="cpu")
+                model, active_backend = _load_embedding_model(name)
+                if model is not None:
                     dim = model.get_sentence_embedding_dimension()
                     model_name = name
-                except Exception as exc:
-                    _respond({"ok": False, "error": f"Model load failed: {exc}"})
+                else:
+                    _respond({"ok": False, "error": "Model load failed"})
                     continue
             try:
-                # torch.inference_mode prevents autograd graph accumulation
-                # which causes silent memory leaks over long-running sessions.
-                try:
-                    import torch
-                    with torch.inference_mode():
-                        vecs = model.encode(texts, normalize_embeddings=True)
-                except ImportError:
-                    vecs = model.encode(texts, normalize_embeddings=True)
+                vecs = model.encode(texts, normalize_embeddings=True)
                 if isinstance(vecs, np.ndarray) and vecs.ndim == 2:
                     result = [vecs[i].tolist() for i in range(vecs.shape[0])]
                 else:
@@ -144,6 +163,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

@@ -263,16 +263,32 @@ def run_recall(
         for r in response.results:
             trust_scorer.update_on_access("fact", r.fact.fact_id, profile_id)
 
-    # V3.3.16: Access count update only — no redundant embedding call.
-    # Fisher Bayesian variance update moved to store_pipeline (write-time)
-    # to avoid per-recall memory pressure from numpy array creation.
-    # Previously: embedder.embed(query) here duplicated the embed call
-    # already done in retrieval engine, creating 768-dim numpy arrays
-    # 304 times during benchmark → pymalloc arena fragmentation → 25GB.
+    # 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 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:
-        db.update_fact(r.fact.fact_id, {
+        updates: dict[str, object] = {
             "access_count": r.fact.access_count + 1,
-        })
+        }
+        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)
+            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)
     hook_ctx["result_count"] = len(response.results)

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

@@ -40,6 +40,9 @@ os.environ["PYTORCH_MPS_MEM_LIMIT"] = "0"
 os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 os.environ["TORCH_DEVICE"] = "cpu"
+# V3.3.17: Disable CoreML EP for ONNX Runtime. CoreML compiles execution
+# plans that consume 3-5GB on ARM64 Mac. CPU EP is ~500MB and fast enough.
+os.environ["ORT_DISABLE_COREML"] = "1"
 
 # SIGTERM bridge for Docker/systemd
 if sys.platform != "win32":
@@ -124,10 +127,12 @@ def _worker_main() -> None:
             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 = [
-                        ("What is the capital of France?", "Paris is the capital of France."),
-                        ("Who wrote Hamlet?", "Shakespeare wrote many plays."),
-                        ("What color is the sky?", "The sky is blue on a clear day."),
+                        (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
@@ -174,6 +179,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/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: