superlocalmemory 3.6.8__tar.gz → 3.6.9__tar.gz

{superlocalmemory-3.6.8/src/superlocalmemory.egg-info → superlocalmemory-3.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.6.8
+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

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.6.8"
+version = "3.6.9"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/src/superlocalmemory/__init__.py

@@ -28,7 +28,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.6.8"
+__version__ = "3.6.9"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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()

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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(

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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
 

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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,

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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")):

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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)",

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/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:

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9}/src/superlocalmemory/server/unified_daemon.py

@@ -746,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,
@@ -881,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
 
@@ -1210,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)
@@ -2222,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])

{superlocalmemory-3.6.8 → superlocalmemory-3.6.9/src/superlocalmemory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.6.8
+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