superlocalmemory 3.6.7 → 3.6.9

package/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to SuperLocalMemory V3 will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.6.9] - 2026-06-11
+
+### Fixed
+- **BUG-A: Health monitor no longer kills the embedding worker under memory pressure.** The watchdog now spares the embedding worker (load-bearing for recall quality) and prefers the reranker instead. The RSS budget defaults to 40% of physical RAM (floor 2500 MB) rather than a hardcoded 2500 MB, preventing thrash on machines with ≥8 GB. `SLM_RSS_BUDGET_MB` env and a new `"health"` config section give full operator control. `HealthConfig` dataclass + `SLMConfig.load()` parsing added so config.json `"health"` keys now actually take effect.
+- **#34: Mesh tools no longer block the daemon event loop.** All 8 async mesh tools wrapped `_ensure_registered` and `_mesh_request` in `asyncio.to_thread` so the blocking loopback HTTP calls leave the event loop (v3.6.7 in-process transport made this a self-deadlock). MCP lifespan hardened so a tool-level exception cannot propagate to uvicorn's shutdown handler. `heartbeat_active` and `registered` now return live state instead of hardcoded literals.
+- **#35: `session_init` now returns a `session_id`.** Clients pass it to `remember()` and `close_session()`. `store_fast` lifts `session_id` from metadata onto the `MemoryRecord` row so facts are correctly attributed. `close_session` queries the DB for the most recent session instead of chasing a phantom `_last_session_id` that was never assigned — `summary_events_created` now returns real counts.
+- **#36-1: HTTP MCP reachable from LAN.** New `SLM_MCP_ALLOWED_HOSTS` (opt-in, default localhost-only) overrides MCP's DNS-rebinding protection. Accepts comma-separated `host:port*` patterns or `*` to disable protection entirely on a trusted LAN.
+- **#36-2: `slm mcp` and the HTTP daemon no longer race for port 8765.** `ensure_daemon` now checks TCP connectivity in addition to PID file + HTTP health, detecting systemd-started daemons mid-startup before attempting a second bind. `SLM_DAEMON_PORT` is now fully wired end-to-end (previously only read in `commands.py` URL building, not in the actual uvicorn bind or `_start_daemon_subprocess`).
+- **#32: Docs correctly state Python 3.11+ requirement** (was "3.10 or later"). Added Ubuntu 22.04 deadsnakes install instructions and a new `docs/install-linux.md` guide.
+
+### Added
+- `HealthConfig` dataclass in `core/config.py` and `"health"` section parsing in `SLMConfig.load()`.
+- `docs/distributed-deployment.md` — complete guide for LXC/container/multi-machine setups, including a full ~90-entry `SLM_*` environment variable reference table (closes #33 + #37).
+- `docs/install-linux.md` — Ubuntu 22.04 / Debian install guide with venv, pipx, and pyenv options, plus a systemd unit template.
+
+## [3.6.8] - 2026-06-11 — Runtime recall-health monitor (self-healing recall)
+
+### Fixed
+- **Silent recall degradation eliminated.** On a long-running daemon the cold full-fusion recall could exceed the MCP pool's 30s timeout, so `session_init` silently fell back to FTS5/BM25 keyword-only ("DEGRADED MODE") — observed 7× in 2 days in production logs. Two root causes are now repaired in-life rather than only at boot:
+  - **Page-cache eviction:** the graph/`association_edges` table gets evicted under memory pressure, so the first recall after idle re-reads it from disk (15–24s+).
+  - **Warm-but-broken embedder:** `OllamaEmbedder.embed` returns `None` on a transient Ollama failure while the boot `_embedding_warm` flag still reports `True`; with `q_emb is None` the engine skips the semantic, hopfield and spreading_activation channels, silently degrading to keyword-only (semantic score `0.0` on every result).
+
+### Added
+- **`server/recall_health.py` — runtime recall-health monitor** (industry-standard 3-tier, validated against Ollama keep-alive, Chroma's active heartbeat, LangChain's circuit breaker and the K8s liveness/readiness split):
+  - **Tier 1 — re-warm:** fires a real `engine.recall` every 5 min to keep the graph page cache hot and nomic-embed resident.
+  - **Tier 2 — readiness probe:** asserts the semantic channel actually fired (`max semantic > 0`); rows-with-`semantic==0` everywhere is the warm-but-broken signature.
+  - **Tier 3 — circuit-breaker self-heal:** resets the embedder's cached `_available` flag (the "available once, cached forever" bug), re-exercises `embed()`, tracks consecutive failures, and logs **CRITICAL** so degradation is never silent.
+- **`/health` now reports `recall_health`** (`recall_healthy`, `consecutive_failures`, `total_heals`, `checks`, `last_semantic_score`) — degradation is visible to operators, not hidden.
+- 8 new tests in `tests/test_core/test_recall_health.py`.
+
 ## [3.6.7] - 2026-06-10 — MCP Streamable-HTTP Transport (Embedded)
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.6.7",
+  "version": "3.6.9",
   "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.6.7"
+version = "3.6.9"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/__init__.py

@@ -1,4 +1,8 @@
-"""SuperLocalMemory — information-geometric agent memory."""
+"""SuperLocalMemory — information-geometric agent memory.
+
+v3.6.9: all 7 retrieval layers at full quality (Hopfield@1000, entity_graph@100,
+SA neighbor-cache fix, fast=True deprecated). See CHANGELOG.md.
+"""
 
 import os
 
@@ -28,7 +32,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.6.7"
+__version__ = "3.6.9"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/daemon.py

@@ -34,7 +34,10 @@ from threading import Thread
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_PORT = 8765  # v3.4.3: unified daemon on 8765 (was 8767)
+try:
+    _DEFAULT_PORT = int(os.environ.get("SLM_DAEMON_PORT", "") or 8765)
+except ValueError:
+    _DEFAULT_PORT = 8765
 _LEGACY_PORT = 8767   # backward-compat redirect
 _DEFAULT_IDLE_TIMEOUT = 0  # v3.4.3: 24/7 default (was 1800)
 _PID_FILE = Path.home() / ".superlocalmemory" / "daemon.pid"
@@ -160,7 +163,13 @@ def _start_daemon_subprocess() -> bool:
         return True
 
     import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
+    # v3.6.9 (#33): pass SLM_DAEMON_PORT as explicit --port= so the daemon
+    # binds the right port even when the env var reaches the subprocess.
+    _target_port = _DEFAULT_PORT
+    cmd = [
+        sys.executable, "-m", "superlocalmemory.server.unified_daemon",
+        "--start", f"--port={_target_port}",
+    ]
     log_dir = Path.home() / ".superlocalmemory" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
     log_file = log_dir / "daemon.log"
@@ -187,7 +196,7 @@ def _start_daemon_subprocess() -> bool:
 
     # Write PID immediately so other callers see it during warmup
     _PID_FILE.write_text(str(proc.pid))
-    _PORT_FILE.write_text(str(_DEFAULT_PORT))
+    _PORT_FILE.write_text(str(_target_port))
 
     return _wait_for_daemon(timeout=60)
 
@@ -237,6 +246,19 @@ def ensure_daemon() -> bool:
         if is_daemon_running():
             return True
 
+        # v3.6.9 (#36): TCP-level check catches a systemd-started daemon that
+        # has bound the port but hasn't written a PID file yet (e.g. different
+        # HOME for the service user vs. the SSH user).  If the port is already
+        # bound, don't start a second daemon — wait for HTTP readiness instead.
+        try:
+            import socket as _socket
+            with _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM) as _s:
+                _s.settimeout(1)
+                if _s.connect_ex(("127.0.0.1", _DEFAULT_PORT)) == 0:
+                    return _wait_for_daemon(timeout=30)
+        except Exception:
+            pass
+
         # Start unified daemon in background — delegated to helper so the
         # same logic can be reused by callers that already hold the lock.
         return _start_daemon_subprocess()

package/src/superlocalmemory/core/config.py

@@ -654,6 +654,25 @@ class AutoInvokeConfig:
     relevance_threshold: float = 0.3           # Legacy compat with AutoRecall
 
 
+# ---------------------------------------------------------------------------
+# Health Config (v3.6.9 BUG-A)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class HealthConfig:
+    """Health-monitor tuning knobs.
+
+    All values have safe defaults so an empty ``"health": {}`` JSON section
+    silently inherits them. The ``global_rss_budget_mb`` default is computed
+    at runtime (40% of physical RAM, floor 2500 MB) so low-RAM boxes keep the
+    old behaviour while large machines are never accidentally throttled.
+    """
+    global_rss_budget_mb: int = 0          # 0 = compute at runtime (40% RAM, floor 2500)
+    heartbeat_timeout_sec: int = 60
+    health_check_interval_sec: int = 15
+    enable_structured_logging: bool = True
+
+
 # ---------------------------------------------------------------------------
 # Master Config
 # ---------------------------------------------------------------------------
@@ -698,6 +717,7 @@ class SLMConfig:
     graph_backend: str = "auto"       # "auto" = cozo if pycozo installed, else sqlite
     vector_backend: str = "auto"      # "auto" = lancedb if installed, else sqlite-vec
     evolution: EvolutionConfig = field(default_factory=EvolutionConfig)
+    health: HealthConfig = field(default_factory=HealthConfig)
 
     # v3.4.3: Daemon configuration
     daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
@@ -789,6 +809,14 @@ class SLMConfig:
                 if k in EvolutionConfig.__dataclass_fields__
             })
 
+        # V3.6.9: Health monitor config (BUG-A — previously silently ignored)
+        hlth = data.get("health", {})
+        if hlth:
+            config.health = HealthConfig(**{
+                k: v for k, v in hlth.items()
+                if k in HealthConfig.__dataclass_fields__
+            })
+
         # V3.4.65: Injection config (additive — defaults if missing from JSON)
         inj = data.get("injection", {}) or {}
         config.injection = InjectionConfig(

package/src/superlocalmemory/core/engine.py

@@ -452,7 +452,9 @@ class MemoryEngine:
         now = datetime.now(timezone.utc).isoformat()
         record = MemoryRecord(
             profile_id=self._profile_id, content=content,
-            session_date=now[:10], metadata=metadata or {},
+            session_date=now[:10],
+            session_id=(metadata or {}).get("session_id", ""),
+            metadata=metadata or {},
         )
         self._db.store_memory(record)
         # Lightweight regex entities (matches store_pipeline verbatim path) so
@@ -520,13 +522,22 @@ class MemoryEngine:
         on a background worker.
 
         V3.4.40 (2026-05-09): ``fast=True`` skips the SpreadingActivation
-        5th channel for sub-second response. The other 4 channels still
-        run. Use when recall must complete before another tool call (e.g.
-        agent recall before WebSearch).
+        channel. Deprecated in v3.6.9 — SA now completes in ~36ms after the
+        neighbor-cache fix; fast=True is slower than fast=False and reduces
+        recall quality. The parameter is accepted for backward compatibility
+        but is silently treated as False.
         """
         self._require_full("recall")
         self._ensure_init()
 
+        if fast:
+            logger.warning(
+                "fast=True is deprecated (v3.6.9): SpreadingActivation now "
+                "completes in ~36ms; fast mode is slower and reduces quality. "
+                "Pass fast=False (the default) to silence this warning."
+            )
+            fast = False
+
         pid = profile_id or self._profile_id
 
         from superlocalmemory.core.recall_pipeline import run_recall

package/src/superlocalmemory/core/health_monitor.py

@@ -130,14 +130,26 @@ class HealthMonitor:
         "superlocalmemory.core.reranker_worker",
         "superlocalmemory.core.recall_worker",
     )
+    # Workers that are LOAD-BEARING for recall quality — never kill these
+    # first; prefer killing the reranker (gracefully degrades) or GC instead.
+    _EMBEDDING_IDENTIFIER = "superlocalmemory.core.embedding_worker"
 
     def __init__(
         self,
-        global_rss_budget_mb: int = 2500,
+        global_rss_budget_mb: int = 0,
         heartbeat_timeout_sec: int = 60,
         check_interval_sec: int = 15,
         enable_structured_logging: bool = True,
     ):
+        # Compute RAM-scaled default when 0 is passed (or when the caller
+        # explicitly passes 0 meaning "auto"). Floor at 2500 so low-RAM boxes
+        # keep the old conservative behaviour.
+        if global_rss_budget_mb <= 0:
+            if PSUTIL_AVAILABLE:
+                phys_mb = psutil.virtual_memory().total // (1024 * 1024)
+                global_rss_budget_mb = max(2500, int(phys_mb * 0.40))
+            else:
+                global_rss_budget_mb = 8000  # safe fallback when psutil absent
         self._budget_mb = global_rss_budget_mb
         self._heartbeat_timeout = heartbeat_timeout_sec
         self._interval = check_interval_sec
@@ -207,7 +219,7 @@ class HealthMonitor:
                     slm_workers.append({
                         "pid": child.pid,
                         "rss_mb": round(rss_mb, 1),
-                        "cmdline": cmdline[:80],
+                        "cmdline": cmdline[:200],
                     })
             except (psutil.NoSuchProcess, psutil.AccessDenied):
                 continue
@@ -225,22 +237,33 @@ class HealthMonitor:
             budget_mb=self._budget_mb,
         )
 
-        # RSS budget enforcement
+        # RSS budget enforcement — spare the embedding worker (load-bearing for
+        # recall quality). Kill the reranker first (degrades gracefully); only
+        # fall back to the embedder if it is the only worker remaining.
         if total_rss_mb > self._budget_mb and slm_workers:
-            heaviest = max(slm_workers, key=lambda w: w["rss_mb"])
+            non_embedder = [
+                w for w in slm_workers
+                if self._EMBEDDING_IDENTIFIER not in w["cmdline"]
+            ]
+            candidate = (
+                max(non_embedder, key=lambda w: w["rss_mb"])
+                if non_embedder
+                else max(slm_workers, key=lambda w: w["rss_mb"])
+            )
             logger.warning(
-                "RSS budget exceeded (%.0fMB > %dMB). Killing heaviest worker PID %d (%.0fMB)",
-                total_rss_mb, self._budget_mb, heaviest["pid"], heaviest["rss_mb"],
+                "RSS budget exceeded (%.0fMB > %dMB). Killing worker PID %d (%.0fMB)",
+                total_rss_mb, self._budget_mb, candidate["pid"], candidate["rss_mb"],
             )
             log_structured(
                 level="warning",
                 operation="rss_budget_kill",
-                killed_pid=heaviest["pid"],
-                killed_rss_mb=heaviest["rss_mb"],
+                killed_pid=candidate["pid"],
+                killed_rss_mb=candidate["rss_mb"],
                 total_rss_mb=round(total_rss_mb, 1),
+                spared_embedder=bool(non_embedder),
             )
             try:
-                psutil.Process(heaviest["pid"]).terminate()
+                psutil.Process(candidate["pid"]).terminate()
             except psutil.NoSuchProcess:
                 pass
 

package/src/superlocalmemory/mcp/tools_active.py

@@ -16,9 +16,12 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import asyncio
+import datetime
 import logging
 import os
 import sqlite3
+import uuid
 from pathlib import Path
 from typing import Callable
 
@@ -213,7 +216,13 @@ def register_active_tools(server, get_engine: Callable) -> None:
             from superlocalmemory.mcp._pool_adapter import PoolError
             degraded_mode = False
             try:
-                response = pool_recall(search_query, limit=max_results, fast=False)
+                # v3.6.9-audit: pool_recall uses blocking urllib under the hood
+                # (DaemonPoolProxy.recall → urllib.urlopen). Must run in a
+                # thread so the async MCP event loop is not stalled — same
+                # fix class as #34 mesh tools deadlock.
+                response = await asyncio.to_thread(
+                    pool_recall, search_query, limit=max_results, fast=False,
+                )
             except (PoolError, Exception) as exc:
                 logger.warning(
                     "session_init: daemon recall failed (%s) — using FTS5 emergency fallback. "
@@ -349,6 +358,13 @@ def register_active_tools(server, get_engine: Callable) -> None:
                     "session_init feedback_count read failed: %s", exc,
                 )
 
+            # v3.6.9 (#35): generate a stable session_id so clients can pass it
+            # to remember() and close_session() for proper session aggregation.
+            session_id = (
+                f"slm-{datetime.datetime.now(datetime.timezone.utc):%Y%m%d}"
+                f"-{uuid.uuid4().hex[:8]}"
+            )
+
             # Register agent + emit event (v3.4.39: SLM_AGENT_ID env support)
             agent_id = _get_agent_id()
             _register_agent(agent_id, pid)
@@ -360,6 +376,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
 
             return {
                 "success": True,
+                "session_id": session_id,
                 "context": context,
                 "memories": memories[:max_results],
                 "memory_count": len(memories),
@@ -430,8 +447,11 @@ def register_active_tools(server, get_engine: Callable) -> None:
                     "confidence": round(decision.confidence, 3),
                 }
 
-            # Auto-store via engine
-            stored = auto.capture(
+            # Auto-store via engine.
+            # pool_store uses blocking urllib (DaemonPoolProxy) — run in
+            # thread so the MCP event loop stays unblocked (#34 class).
+            stored = await asyncio.to_thread(
+                auto.capture,
                 content,
                 category=decision.category,
                 metadata={"agent_id": agent_id, "source": "auto-observe"},
@@ -525,8 +545,24 @@ def register_active_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             sid = session_id or getattr(engine, '_last_session_id', '')
+            # v3.6.9 (#35): _last_session_id was never assigned — fall back to
+            # querying the DB for the most recent session_id instead of silently
+            # returning summary_events_created: 0.
+            if not sid:
+                try:
+                    db = getattr(engine, '_db', None) or getattr(engine, 'db', None)
+                    if db and hasattr(db, 'execute'):
+                        rows = db.execute(
+                            "SELECT session_id FROM memories "
+                            "WHERE session_id != '' ORDER BY created_at DESC LIMIT 1",
+                            ()
+                        )
+                        if rows:
+                            sid = str(rows[0][0])
+                except Exception:
+                    pass
             if not sid:
-                return {"success": False, "error": "No session_id provided"}
+                return {"success": False, "error": "No session_id provided or found"}
             count = engine.close_session(sid)
             return {
                 "success": True,

package/src/superlocalmemory/mcp/tools_core.py

@@ -122,9 +122,13 @@ def register_core_tools(server, get_engine: Callable) -> None:
         # recall window so a parallel/next agent finds memories saved seconds ago.
         # Falls back to pending.db only if the daemon is unreachable.
         try:
+            import asyncio as _asyncio
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
-            if is_daemon_running():
-                resp = daemon_request("POST", "/remember", {
+            # is_daemon_running() and daemon_request() both use blocking urllib
+            # against the same uvicorn server — run in threads so the MCP
+            # event loop stays unblocked (#34 class bug).
+            if await _asyncio.to_thread(is_daemon_running):
+                resp = await _asyncio.to_thread(daemon_request, "POST", "/remember", {
                     "content": content, "tags": tags, "metadata": meta,
                 })
                 if resp and (resp.get("fact_ids") is not None or resp.get("ok")):

package/src/superlocalmemory/mcp/tools_mesh.py

@@ -16,6 +16,7 @@ Auto-heartbeat keeps the session alive as long as the MCP server is running.
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 import os
@@ -141,20 +142,20 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
         global _SESSION_SUMMARY
         _SESSION_SUMMARY = summary or "Active session"
 
-        _ensure_registered()
+        await asyncio.to_thread(_ensure_registered)
 
         # Update summary
-        result = _mesh_request("POST", "/summary", {
-            "peer_id": _PEER_ID,
-            "summary": _SESSION_SUMMARY,
-        })
+        result = await asyncio.to_thread(
+            _mesh_request, "POST", "/summary",
+            {"peer_id": _PEER_ID, "summary": _SESSION_SUMMARY},
+        )
 
         return {
             "peer_id": _PEER_ID,
             "summary": _SESSION_SUMMARY,
             "project_path": _PROJECT_PATH,
-            "registered": True,
-            "heartbeat_active": _HEARTBEAT_THREAD is not None,
+            "registered": _REGISTERED,
+            "heartbeat_active": _HEARTBEAT_THREAD is not None and _HEARTBEAT_THREAD.is_alive(),
             "broker_response": result,
         }
 
@@ -165,8 +166,8 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
         Shows other Claude Code, Cursor, or AI agent sessions that are
         connected to the same SLM mesh network.
         """
-        _ensure_registered()
-        result = _mesh_request("GET", "/peers")
+        await asyncio.to_thread(_ensure_registered)
+        result = await asyncio.to_thread(_mesh_request, "GET", "/peers")
         peers = (result or {}).get("peers", [])
         return {
             "peers": peers,
@@ -185,12 +186,11 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
                 - "project:/path/to/dir" (all sessions in that project directory)
             message: The message content (max 4KB — use file paths for large data)
         """
-        _ensure_registered()
-        result = _mesh_request("POST", "/send", {
-            "from_peer": _PEER_ID,
-            "to_peer": to,
-            "content": message,
-        })
+        await asyncio.to_thread(_ensure_registered)
+        result = await asyncio.to_thread(
+            _mesh_request, "POST", "/send",
+            {"from_peer": _PEER_ID, "to_peer": to, "content": message},
+        )
         return result or {"error": "Failed to send message"}
 
     @server.tool()
@@ -201,18 +201,19 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
         Broadcast/project messages are delivered to ALL matching sessions.
         Messages auto-expire after 48 hours.
         """
-        _ensure_registered()
+        await asyncio.to_thread(_ensure_registered)
         project = _PROJECT_PATH or _detect_project_path()
-        messages = _mesh_request(
-            "GET", f"/inbox/{_PEER_ID}?project_path={project}",
+        messages = await asyncio.to_thread(
+            _mesh_request, "GET", f"/inbox/{_PEER_ID}?project_path={project}",
         )
         msg_list = (messages or {}).get("messages", [])
         # Auto-mark unread messages as read
         unread_ids = [m["id"] for m in msg_list if not m.get("read")]
         if unread_ids:
-            _mesh_request("POST", f"/inbox/{_PEER_ID}/read", {
-                "message_ids": unread_ids,
-            })
+            await asyncio.to_thread(
+                _mesh_request, "POST", f"/inbox/{_PEER_ID}/read",
+                {"message_ids": unread_ids},
+            )
         return {
             "messages": msg_list,
             "count": len(msg_list),
@@ -231,21 +232,20 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
             value: Value to set (only for action="set")
             action: "get" (read all or one key), "set" (write a key)
         """
-        _ensure_registered()
+        await asyncio.to_thread(_ensure_registered)
 
         if action == "set" and key:
-            result = _mesh_request("POST", "/state", {
-                "key": key,
-                "value": value,
-                "set_by": _PEER_ID,
-            })
+            result = await asyncio.to_thread(
+                _mesh_request, "POST", "/state",
+                {"key": key, "value": value, "set_by": _PEER_ID},
+            )
             return result or {"error": "Failed to set state"}
 
         if key:
-            result = _mesh_request("GET", f"/state/{key}")
+            result = await asyncio.to_thread(_mesh_request, "GET", f"/state/{key}")
             return result or {"key": key, "value": None}
 
-        result = _mesh_request("GET", "/state")
+        result = await asyncio.to_thread(_mesh_request, "GET", "/state")
         return result or {"state": {}}
 
     @server.tool()
@@ -261,12 +261,11 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
             file_path: Path to the file
             action: "query" (check lock), "acquire" (lock file), "release" (unlock)
         """
-        _ensure_registered()
-        result = _mesh_request("POST", "/lock", {
-            "file_path": file_path,
-            "action": action,
-            "locked_by": _PEER_ID,
-        })
+        await asyncio.to_thread(_ensure_registered)
+        result = await asyncio.to_thread(
+            _mesh_request, "POST", "/lock",
+            {"file_path": file_path, "action": action, "locked_by": _PEER_ID},
+        )
         return result or {"error": "Lock operation failed"}
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
@@ -275,7 +274,7 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
 
         Shows the activity log of the mesh network.
         """
-        result = _mesh_request("GET", "/events")
+        result = await asyncio.to_thread(_mesh_request, "GET", "/events")
         return result or {"events": []}
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
@@ -284,10 +283,10 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
 
         Shows broker uptime, peer count, and connection status.
         """
-        result = _mesh_request("GET", "/status")
+        result = await asyncio.to_thread(_mesh_request, "GET", "/status")
         if result:
             result["my_peer_id"] = _PEER_ID
-            result["heartbeat_active"] = _HEARTBEAT_THREAD is not None
+            result["heartbeat_active"] = _HEARTBEAT_THREAD is not None and _HEARTBEAT_THREAD.is_alive()
         return result or {
             "broker_up": False,
             "error": "Cannot reach mesh broker. Is the daemon running? (slm serve start)",

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -170,8 +170,11 @@ class SpreadingActivation:
         for fact_id, similarity in seeds:
             activations[fact_id] = cfg.alpha * similarity
 
-        # Precompute out-degrees for fan effect
+        # Cache neighbor lookups and out-degrees across iterations — same node
+        # often survives multiple rounds via self-retention (delta=0.5);
+        # caching here cuts ~80% of SQL queries vs per-iteration re-query.
         degree_cache: dict[str, int] = {}
+        neighbor_cache: dict[str, list] = {}
 
         # Steps 2-4, repeated T times
         for _iteration in range(cfg.max_iterations):
@@ -181,8 +184,10 @@ class SpreadingActivation:
                 if activation < 0.001:
                     continue
 
-                # Get neighbors from BOTH tables (Rule 13)
-                neighbors = self._get_unified_neighbors(node_id, profile_id)
+                # Get neighbors from BOTH tables (Rule 13) — cached per node
+                if node_id not in neighbor_cache:
+                    neighbor_cache[node_id] = self._get_unified_neighbors(node_id, profile_id)
+                neighbors = neighbor_cache[node_id]
 
                 # Out-degree for fan effect normalization
                 if node_id not in degree_cache:

package/src/superlocalmemory/server/recall_health.py

@@ -0,0 +1,237 @@
+"""Runtime recall-health monitor — keep the 6-channel recall path warm,
+detect a "warm-but-broken" embedder at runtime, and self-heal it (v3.6.8).
+
+Why this exists
+---------------
+On a long-running daemon the cold full-fusion recall could exceed the MCP
+pool's 30s timeout, and ``session_init`` then silently fell back to FTS5/BM25
+("DEGRADED MODE") — observed 7×/2 days in production logs. Two root causes:
+
+1. **Page-cache eviction.** The ~100 MB ``association_edges`` / graph table is
+   evicted under memory pressure, so the first recall after idle re-reads it
+   from disk (15-24 s+), blowing the pool timeout.
+2. **Silent embedder death.** ``OllamaEmbedder.embed`` returns ``None`` on a
+   transient Ollama failure, while the boot-set ``_embedding_warm`` flag still
+   reports ``True``. With ``q_emb is None`` the engine skips the semantic,
+   hopfield and spreading_activation channels — recall silently degrades to
+   keyword-only (``semantic`` score ``0.0`` on every result).
+
+The boot warmup (``_warmup_recall``) runs ONCE and never again, so neither
+condition is repaired in-life.
+
+The fix — an industry-standard 3-tier monitor, validated against Ollama
+keep-alive, Chroma's active heartbeat, LangChain's circuit breaker and the
+Kubernetes liveness/readiness split:
+
+* **Tier 1 — RE-WARM.** Fire a real ``engine.recall`` every ``interval_s`` to
+  keep the graph page cache hot and nomic-embed resident.
+* **Tier 2 — READINESS PROBE.** Assert the semantic channel actually fired
+  (``max semantic > 0``). Rows returned with ``semantic == 0`` everywhere is the
+  warm-but-broken signature → the embedder is returning ``None``.
+* **Tier 3 — CIRCUIT-BREAKER SELF-HEAL.** Reset the embedder's cached
+  ``_available`` flag (the "available once, cached forever" bug), re-exercise
+  ``embed()``, track consecutive failures, and log **CRITICAL** so the
+  degradation is never silent.
+
+All logic is fail-soft: a crash in the monitor never takes down the daemon.
+"""
+from __future__ import annotations
+
+import logging
+import threading
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+# A stable probe query. Content-agnostic: we only assert that *some* result
+# carries a non-zero semantic score, which proves the embedder + semantic
+# channel are alive end-to-end.
+DEFAULT_PROBE = "memory recall health probe"
+# A distinct string for the heal embed() call so it is obvious in thread dumps
+# / Ollama logs and never collides with a real cached query embedding.
+HEAL_PROBE = "__recall_health_rewarm__"
+
+# Default cadence. 5 min keeps nomic-embed resident (Ollama default unload is
+# 5 min) and the page cache warm without meaningful load.
+DEFAULT_INTERVAL_S = 300
+
+
+@dataclass
+class RecallHealth:
+    """Mutable health state for the recall path."""
+
+    healthy: bool = True
+    consecutive_failures: int = 0
+    total_heals: int = 0
+    checks: int = 0
+    last_semantic_score: float = 0.0
+    last_error: str = ""
+
+
+def _max_semantic(results) -> float:
+    """Largest semantic channel score across results (0.0 if none)."""
+    best = 0.0
+    for r in results:
+        cs = getattr(r, "channel_scores", None) or {}
+        try:
+            best = max(best, float(cs.get("semantic", 0.0) or 0.0))
+        except (TypeError, ValueError):
+            continue
+    return best
+
+
+def _get_embedder(engine):
+    """Locate the engine's embedder (full mode: engine._embedder; some paths
+    hang it off the retrieval engine)."""
+    emb = getattr(engine, "_embedder", None)
+    if emb is None:
+        re_eng = getattr(engine, "_retrieval_engine", None)
+        emb = getattr(re_eng, "_embedder", None) if re_eng is not None else None
+    return emb
+
+
+def _heal_embedder(engine, *, log) -> bool:
+    """Tier 3: reset the cached availability flag and re-exercise the embedder.
+
+    ``OllamaEmbedder.is_available`` caches its first result forever, so once
+    Ollama blips the flag can stay stale. Clearing ``_available`` forces a
+    re-probe; ``embed()`` itself always re-attempts the HTTP call, so a single
+    successful embed proves recovery. Returns True iff the embedder produced a
+    vector.
+    """
+    emb = _get_embedder(engine)
+    if emb is None:
+        log.critical("recall-health: no embedder on engine — cannot self-heal")
+        return False
+    # Reset the "available once, cached forever" flag if present.
+    if hasattr(emb, "_available"):
+        try:
+            emb._available = None
+        except Exception:  # pragma: no cover - defensive
+            pass
+    try:
+        vec = emb.embed(HEAL_PROBE)
+    except Exception as exc:
+        log.warning("recall-health: heal embed() raised: %s", exc)
+        return False
+    return vec is not None and bool(vec)
+
+
+def run_health_tick(engine, state: RecallHealth, *, probe: str = DEFAULT_PROBE,
+                    log=logger) -> RecallHealth:
+    """One monitor tick: re-warm (Tier 1), probe (Tier 2), self-heal (Tier 3).
+
+    Mutates and returns ``state``. Never raises — a timed-out / failing recall
+    marks the path unhealthy instead of propagating.
+    """
+    state.checks += 1
+
+    # Tier 1: re-warm. A real full-fusion recall keeps the graph page cache hot
+    # and the embedder resident.
+    try:
+        resp = engine.recall(probe, limit=3, fast=False)
+    except Exception as exc:
+        state.healthy = False
+        state.consecutive_failures += 1
+        state.last_error = f"recall raised: {exc}"
+        log.critical(
+            "recall-health: re-warm recall FAILED (%s) — recall path unhealthy",
+            exc,
+        )
+        return state
+
+    results = list(getattr(resp, "results", []) or [])
+    sem = _max_semantic(results)
+    state.last_semantic_score = sem
+
+    # Tier 2: readiness. Rows present but semantic never fired == warm-but-broken.
+    # Zero results is NOT this signature (could be an empty/filtered corpus).
+    broken = bool(results) and sem <= 0.0
+    if not broken:
+        if not state.healthy:
+            log.warning(
+                "recall-health: RECOVERED (semantic=%.3f, %d results)",
+                sem, len(results),
+            )
+        state.healthy = True
+        state.consecutive_failures = 0
+        state.last_error = ""
+        return state
+
+    # Tier 3: self-heal.
+    log.critical(
+        "recall-health: semantic channel DEAD (%d results, max semantic=0.0) "
+        "— embedder returning None; attempting self-heal",
+        len(results),
+    )
+    if _heal_embedder(engine, log=log):
+        state.total_heals += 1
+        state.healthy = True
+        state.consecutive_failures = 0
+        state.last_error = ""
+        log.warning("recall-health: embedder self-heal SUCCEEDED (re-warmed)")
+    else:
+        state.healthy = False
+        state.consecutive_failures += 1
+        state.last_error = "semantic channel dead; embedder heal failed"
+        log.critical(
+            "recall-health: self-heal FAILED — recall DEGRADED to keyword-only "
+            "(consecutive_failures=%d)", state.consecutive_failures,
+        )
+    return state
+
+
+def health_monitor_loop(engine, *, interval_s: int, stop_event: threading.Event,
+                        state: RecallHealth, probe: str = DEFAULT_PROBE,
+                        log=logger) -> None:
+    """Background loop. Sleeps ``interval_s`` between ticks; exits promptly when
+    ``stop_event`` is set. An initial short delay avoids racing boot warmup."""
+    # Initial delay (bounded) so we don't pile onto the boot warmup threads.
+    if stop_event.wait(min(interval_s, 60)):
+        return
+    while not stop_event.is_set():
+        try:
+            run_health_tick(engine, state, probe=probe, log=log)
+        except Exception as exc:  # pragma: no cover - belt & suspenders
+            log.warning("recall-health: tick crashed (non-fatal): %s", exc)
+        if stop_event.wait(interval_s):
+            break
+
+
+# Module-level state so /health can surface the latest verdict without holding
+# a reference to the thread.
+_GLOBAL_STATE = RecallHealth()
+
+
+def start_recall_health_monitor(engine, *, interval_s: int = DEFAULT_INTERVAL_S,
+                                probe: str = DEFAULT_PROBE, log=None):
+    """Start the monitor as a daemon thread. Returns ``(thread, stop_event,
+    state)``. The state is the shared module-level state read by
+    :func:`get_recall_health`."""
+    log = log or logger
+    state = _GLOBAL_STATE
+    stop = threading.Event()
+    t = threading.Thread(
+        target=health_monitor_loop,
+        kwargs=dict(
+            engine=engine, interval_s=interval_s, stop_event=stop,
+            state=state, probe=probe, log=log,
+        ),
+        daemon=True,
+        name="recall-health",
+    )
+    t.start()
+    return t, stop, state
+
+
+def get_recall_health() -> dict:
+    """Snapshot for /health surfacing (visibility — never silent degradation)."""
+    s = _GLOBAL_STATE
+    return {
+        "recall_healthy": s.healthy,
+        "consecutive_failures": s.consecutive_failures,
+        "total_heals": s.total_heals,
+        "checks": s.checks,
+        "last_semantic_score": round(s.last_semantic_score, 4),
+        "last_error": s.last_error,
+    }

package/src/superlocalmemory/server/unified_daemon.py

@@ -683,6 +683,25 @@ async def lifespan(application: FastAPI):
         threading.Thread(target=_warmup_recall, daemon=True, name="recall-warmup").start()
         threading.Thread(target=_backfill_vector_store, daemon=True, name="vs-backfill").start()
 
+        # v3.6.8: Runtime recall-health monitor. The three warmups above run
+        # ONCE at boot; on a long-running daemon the graph page cache gets
+        # evicted and the embedder can start returning None while _embedding_warm
+        # still claims True — both silently degrade recall to keyword-only BM25
+        # (observed: session_init "pool.recall timed out → DEGRADED MODE", 7×/2d).
+        # This monitor re-warms + actively probes the semantic channel + self-heals
+        # a dead embedder for the daemon's whole life. See server/recall_health.py.
+        try:
+            from superlocalmemory.server.recall_health import (
+                start_recall_health_monitor,
+            )
+            _rh_thread, _rh_stop, _ = start_recall_health_monitor(engine)
+            application.state.recall_health_stop = _rh_stop
+        except Exception as _rh_exc:
+            logger.warning(
+                "recall-health monitor start failed (non-fatal): %s", _rh_exc,
+            )
+            application.state.recall_health_stop = None
+
         # v3.4.37: QueueConsumer uses daemon's engine directly via adapter.
         # Previously routed through WorkerPool → recall_worker subprocess,
         # which loaded a duplicate MemoryEngine (~800 MB waste).
@@ -727,8 +746,12 @@ async def lifespan(application: FastAPI):
     try:
         from superlocalmemory.core.health_monitor import HealthMonitor
         health_config = getattr(config, 'health', None)
+        # v3.6.9 BUG-A: env override + RAM-scaled default (HealthMonitor computes
+        # 40% of physical RAM when budget=0). SLM_RSS_BUDGET_MB takes priority.
+        _env_budget = int(os.environ.get("SLM_RSS_BUDGET_MB", "0") or 0)
+        _cfg_budget = getattr(health_config, 'global_rss_budget_mb', 0) if health_config else 0
         monitor = HealthMonitor(
-            global_rss_budget_mb=getattr(health_config, 'global_rss_budget_mb', 2500) if health_config else 2500,
+            global_rss_budget_mb=_env_budget or _cfg_budget or 0,
             heartbeat_timeout_sec=getattr(health_config, 'heartbeat_timeout_sec', 60) if health_config else 60,
             check_interval_sec=getattr(health_config, 'health_check_interval_sec', 15) if health_config else 15,
             enable_structured_logging=getattr(health_config, 'enable_structured_logging', True) if health_config else True,
@@ -862,12 +885,21 @@ async def lifespan(application: FastAPI):
     # lifespan every POST /mcp 500s with "Task group is not initialized."
     # AsyncExitStack enters the context only when _mcp_app was mounted; if the
     # mount failed (non-fatal) the daemon starts normally without HTTP MCP.
+    # v3.6.9 (#34): wrap the MCP lifespan in shield so an unhandled exception
+    # or tool-level cancellation inside a session manager task group cannot
+    # propagate out and trigger uvicorn's graceful-shutdown handler.
     async with AsyncExitStack() as _mcp_stack:
         if _mcp_app is not None:
-            await _mcp_stack.enter_async_context(
-                _mcp_app.router.lifespan_context(_mcp_app)
-            )
-            logger.info("MCP HTTP session manager started (Streamable-HTTP on /mcp)")
+            try:
+                await _mcp_stack.enter_async_context(
+                    _mcp_app.router.lifespan_context(_mcp_app)
+                )
+                logger.info("MCP HTTP session manager started (Streamable-HTTP on /mcp)")
+            except Exception as _mcp_lifespan_exc:
+                logger.warning(
+                    "MCP HTTP session manager failed to start (non-fatal, stdio still works): %s",
+                    _mcp_lifespan_exc,
+                )
 
         yield
 
@@ -968,6 +1000,14 @@ async def lifespan(application: FastAPI):
         except Exception as exc:  # pragma: no cover — defensive
             logger.warning("recall_queue close failed: %s", exc)
 
+    # v3.6.8: Stop recall-health monitor (owns a daemon thread).
+    _rh_stop = getattr(application.state, "recall_health_stop", None)
+    if _rh_stop is not None:
+        try:
+            _rh_stop.set()
+        except Exception as exc:  # pragma: no cover — defensive
+            logger.warning("recall_health monitor stop failed: %s", exc)
+
     # Stop HealthMonitor (health_monitor.py owns a daemon thread).
     _health = getattr(application.state, "health_monitor", None)
     if _health is not None:
@@ -1183,6 +1223,27 @@ def create_app() -> FastAPI:
         from superlocalmemory.mcp.server import server as _mcp_fastmcp
         _mcp_fastmcp.settings.streamable_http_path = "/"
         _mcp_fastmcp._session_manager = None  # Defensive reset for idempotency
+        # v3.6.9 (#36): configure DNS-rebinding protection from env.
+        # Default: localhost-only (safe). Set SLM_MCP_ALLOWED_HOSTS=192.168.x.y:*
+        # (comma-separated, e.g. "192.168.50.144:*,slm.lan:*") to open to a LAN.
+        # Use "*" to disable protection entirely (trusted private network only).
+        # TransportSecuritySettings imported lazily here so that MCP mount
+        # works on older SDK versions when SLM_MCP_ALLOWED_HOSTS is not set.
+        _mcp_allowed = os.environ.get("SLM_MCP_ALLOWED_HOSTS", "").strip()
+        if _mcp_allowed:
+            from mcp.server.transport_security import TransportSecuritySettings
+            if _mcp_allowed == "*":
+                _mcp_fastmcp.settings.transport_security = TransportSecuritySettings(
+                    enable_dns_rebinding_protection=False,
+                )
+            else:
+                _hosts = [h.strip() for h in _mcp_allowed.split(",") if h.strip()]
+                _mcp_fastmcp.settings.transport_security = TransportSecuritySettings(
+                    enable_dns_rebinding_protection=True,
+                    allowed_hosts=_hosts,
+                    allowed_origins=[f"http://{h}" for h in _hosts],
+                )
+            logger.info("MCP transport security: allowed_hosts=%r", _mcp_allowed)
         global _mcp_app
         _mcp_app = _mcp_fastmcp.streamable_http_app()
         application.mount("/mcp", _mcp_app)
@@ -1579,6 +1640,13 @@ def _register_daemon_routes(application: FastAPI) -> None:
         _update_activity()
         # Non-blocking peek: report status without forcing a re-init.
         engine = getattr(application.state, "engine", None)
+        # v3.6.8: surface the recall-health verdict so a silently-degraded
+        # recall path (warm-but-broken embedder) is VISIBLE, never silent.
+        try:
+            from superlocalmemory.server.recall_health import get_recall_health
+            _recall_health = get_recall_health()
+        except Exception:
+            _recall_health = {"recall_healthy": None}
         return {
             "status": "ok",
             "pid": os.getpid(),
@@ -1587,6 +1655,9 @@ def _register_daemon_routes(application: FastAPI) -> None:
             # v3.4.52: clients can poll this to wait for embedding model
             # readiness before issuing recall calls.
             "embedding_warm": _embedding_warm,
+            # v3.6.8: True iff the semantic channel actually fired on the last
+            # health probe; includes self-heal counters.
+            "recall_health": _recall_health,
         }
 
     @application.get("/recall")
@@ -2185,7 +2256,9 @@ if __name__ == "__main__":
     # freshly-sized file.
     rotate_oversized_logs()
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
-    port = _DEFAULT_PORT
+    # v3.6.9 (#33): honour SLM_DAEMON_PORT env so operators can configure the
+    # port without changing the launch command. --port= arg takes precedence.
+    port = int(os.environ.get("SLM_DAEMON_PORT", "") or _DEFAULT_PORT)
     for arg in sys.argv:
         if arg.startswith("--port="):
             port = int(arg.split("=")[1])

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.6.7
+Version: 3.6.9
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later

package/src/superlocalmemory.egg-info/SOURCES.txt

@@ -360,6 +360,7 @@ src/superlocalmemory/retrieval/vector_store.py
 src/superlocalmemory/server/__init__.py
 src/superlocalmemory/server/api.py
 src/superlocalmemory/server/bandit_loops.py
+src/superlocalmemory/server/recall_health.py
 src/superlocalmemory/server/recall_serializer.py
 src/superlocalmemory/server/security_middleware.py
 src/superlocalmemory/server/ui.py