superlocalmemory 3.6.10 → 3.6.12

package/src/superlocalmemory/mcp/agent_context.py

@@ -15,8 +15,12 @@ import contextvars
 import os
 import re
 
+# v3.6.12 (parity-1): default is "" (the "no agent routed" sentinel), NOT the
+# user-visible "mcp_client". Sanitized agent ids are [A-Za-z0-9._-], so "" can
+# never collide — a client that explicitly routes to /mcp/mcp_client is now
+# distinguishable from a bare /mcp/ request with no agent segment.
 _current_agent_id: contextvars.ContextVar[str] = contextvars.ContextVar(
-    "slm_agent_id", default="mcp_client"
+    "slm_agent_id", default=""
 )
 
 # Agent ids arrive from an untrusted URL path segment. They are ATTRIBUTION
@@ -42,8 +46,8 @@ def get_current_agent_id(env_fallback: bool = True) -> str:
     fall through to the SLM_AGENT_ID env var instead.
     """
     ctx_id = _current_agent_id.get()
-    if ctx_id != "mcp_client":
-        return ctx_id
+    if ctx_id:
+        return ctx_id  # an explicitly-routed agent id (incl. "mcp_client")
     if env_fallback:
         return os.environ.get("SLM_AGENT_ID", "mcp_client")
     return "mcp_client"

package/src/superlocalmemory/mcp/server.py

@@ -104,6 +104,8 @@ _ESSENTIAL_TOOLS: set[str] = {
     "reinforce_assertion", "contradict_assertion",
     # v3.4.11: Skill evolution (3)
     "evolve_skill", "skill_health", "skill_lineage",
+    # v3.6.11: Surface B Optimize tools (5)
+    "slm_compress", "slm_retrieve", "slm_cache_set", "slm_cache_get", "slm_optimize_stats",
 }
 
 # v3.4.4: Mesh tools — enabled if mesh_enabled in config or SLM_MCP_MESH_TOOLS=1
@@ -189,6 +191,8 @@ register_code_graph_tools(_target, get_engine)  # CodeGraph: filtered like other
 register_mesh_tools(_target, get_engine)  # v3.4.4: Mesh P2P tools — ships with SLM, no separate slm-mesh needed
 register_learning_tools(_target, get_engine)  # v3.4.7: Two-way learning tools
 register_evolution_tools(_target, get_engine)  # v3.4.11: Skill evolution tools
+from superlocalmemory.mcp.tools_optimize import register_optimize_tools
+register_optimize_tools(_target)  # v3.6.11: Surface B Optimize tools (proxy-free)
 
 
 # V3.3.21: Eager engine warmup — start initializing BEFORE first tool call.

package/src/superlocalmemory/mcp/tools_core.py

@@ -309,7 +309,10 @@ def register_core_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             pid = profile_id or engine.profile_id
-            facts = engine._db.get_all_facts(pid)[:limit]
+            # v3.6.12 (search-2): push the limit into the query — was loading the
+            # ENTIRE facts table (deserializing every 768-float embedding) just
+            # to return the top N. get_all_facts preserves created_at DESC order.
+            facts = engine._db.get_all_facts(pid, limit=limit)
             items = []
             for f in facts:
                 items.append({
@@ -401,6 +404,15 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 # Dashboard not installed — profile switch still works for MCP/CLI
                 logger.debug("Dashboard routes not available, profile set in engine only")
 
+            # v3.6.12 (search-3): recall/delete run in a separate worker
+            # subprocess that caches its engine (and profile_id) at init. Recycle
+            # it so the NEXT recall uses the new profile instead of the stale one.
+            try:
+                from superlocalmemory.core.worker_pool import WorkerPool
+                WorkerPool.shared().shutdown()
+            except Exception:
+                logger.debug("worker-pool recycle on profile switch skipped")
+
             return {
                 "success": True,
                 "previous_profile": old,

package/src/superlocalmemory/mcp/tools_mesh.py

@@ -76,7 +76,7 @@ def _mesh_request(method: str, path: str, body: dict | None = None) -> dict | No
 
 def _ensure_registered() -> None:
     """Register this session with the mesh broker if not already."""
-    global _REGISTERED, _PROJECT_PATH
+    global _REGISTERED, _PROJECT_PATH, _PEER_ID
     if _REGISTERED:
         return
 
@@ -89,6 +89,11 @@ def _ensure_registered() -> None:
         "agent_type": os.environ.get("CLAUDE_AGENT_TYPE", "claude_code"),
     })
     if result:
+        # v3.6.12 (mesh-1): the broker mints its OWN peer_id (RegisterRequest has
+        # no peer_id field, so our body value is dropped by pydantic). Adopt the
+        # broker's id BEFORE starting the heartbeat, otherwise heartbeat/send/
+        # inbox all target a non-existent peer → 404s and the session is reaped.
+        _PEER_ID = result.get("peer_id", _PEER_ID)
         _REGISTERED = True
         _start_heartbeat()
         pending = result.get("pending_messages", 0)
@@ -191,7 +196,7 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
             _mesh_request, "POST", "/send",
             {"from_peer": _PEER_ID, "to_peer": to, "content": message},
         )
-        return result or {"error": "Failed to send message"}
+        return result or {"ok": False, "error": "Failed to send message"}
 
     @server.tool()
     async def mesh_inbox() -> dict:
@@ -207,8 +212,11 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
             _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")]
+        # Auto-mark unread messages as read. v3.6.12 (failopen-2): use .get("id")
+        # — a malformed broker message without an "id" key used to raise KeyError
+        # out to the agent, violating the never-raise contract.
+        unread_ids = [m["id"] for m in msg_list
+                      if not m.get("read") and m.get("id") is not None]
         if unread_ids:
             await asyncio.to_thread(
                 _mesh_request, "POST", f"/inbox/{_PEER_ID}/read",
@@ -239,7 +247,7 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
                 _mesh_request, "POST", "/state",
                 {"key": key, "value": value, "set_by": _PEER_ID},
             )
-            return result or {"error": "Failed to set state"}
+            return result or {"ok": False, "error": "Failed to set state"}
 
         if key:
             result = await asyncio.to_thread(_mesh_request, "GET", f"/state/{key}")
@@ -266,7 +274,7 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
             _mesh_request, "POST", "/lock",
             {"file_path": file_path, "action": action, "locked_by": _PEER_ID},
         )
-        return result or {"error": "Lock operation failed"}
+        return result or {"ok": False, "error": "Lock operation failed"}
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def mesh_events() -> dict:

package/src/superlocalmemory/mcp/tools_optimize.py

@@ -0,0 +1,304 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM v3.6.11 — Surface B: MCP Optimize Tools.
+
+Five proxy-free tools exposing compression (reversible via CCR) and
+routed-result caching WITHOUT touching ANTHROPIC_BASE_URL, so the full
+1M context window is preserved on any Claude subscription.
+
+Primary Claude conversation turns CANNOT be cached without a proxy.
+These tools cache results the agent explicitly routes through SLM.
+
+Fail-open: every tool body is wrapped in try/except Exception.
+Any internal error returns the input unchanged with ok:False — never raises.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import threading
+import time
+
+from mcp.types import ToolAnnotations
+
+from superlocalmemory.mcp.agent_context import get_current_agent_id
+from superlocalmemory.optimize.compress.ccr import CCRStore, _UUID4_RE
+from superlocalmemory.optimize.compress.router import CompressRouter
+from superlocalmemory.optimize.storage.db import CacheDB, _normalize_tenant_id
+
+logger = logging.getLogger("slm.mcp.tools_optimize")
+
+# ─── Size caps (CWE-400 guards) ───────────────────────────────────────────────
+
+_MAX_COMPRESS_BYTES: int = 1_000_000
+_MAX_KV_VALUE_BYTES: int = 1_000_000
+_MAX_KV_KEY_CHARS: int = 512
+
+# ─── Exported tool name list (used by server.py + tests) ─────────────────────
+
+_OPTIMIZE_TOOL_NAMES = (
+    "slm_compress",
+    "slm_retrieve",
+    "slm_cache_set",
+    "slm_cache_get",
+    "slm_optimize_stats",
+)
+
+# ─── In-module KV counters (thread-safe; MetricsCollector is process-scoped) ─
+
+_kv_lock = threading.Lock()
+_kv_hits: int = 0
+_kv_misses: int = 0
+
+
+def _tenant() -> str:
+    # get_current_agent_id() never returns ""; "mcp_client" is its stdio sentinel.
+    return get_current_agent_id()
+
+
+# ─── Tool registration ────────────────────────────────────────────────────────
+
+
+def register_optimize_tools(server) -> None:
+    """Register the 5 Surface B optimize tools on *server*.
+
+    *server* is duck-typed: must support @server.tool() decorator pattern.
+    Compatible with FastMCP, _FilteredServer, and test _MockServer.
+    """
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def slm_compress(
+        content: str,
+        mode: str = "auto",
+        reversible: bool = True,
+        ttl_seconds: int = 86400,
+    ) -> dict:
+        """Compress text or tool output to reduce context window usage.
+
+        Returns compressed text. If lossy and reversible=True, also returns a
+        ccr_id — pass it to slm_retrieve to recover the exact original.
+
+        Args:
+            content: Text to compress (max 1MB).
+            mode: "normalize" (lossless whitespace) | "auto" | "aggressive".
+            reversible: Store original in CCR for later retrieval.
+            ttl_seconds: CCR lifetime in seconds (default 24h).
+        """
+        try:
+            if not isinstance(content, str) or not content:
+                return {
+                    "ok": False, "compressed": content or "",
+                    "strategy": "none", "tokens_before": 0, "tokens_after": 0,
+                    "ratio": 1.0, "lossy": False, "ccr_id": None,
+                    "note": "empty input",
+                }
+
+            note_parts: list[str] = []
+            if len(content.encode("utf-8")) > _MAX_COMPRESS_BYTES:
+                reversible = False
+                note_parts.append("content over 1MB: ccr skipped")
+
+            if mode == "normalize":
+                # @staticmethod — lossless whitespace collapse, no config/daemon dep.
+                normalized = CompressRouter._normalize_whitespace(content)
+                tb = len(content.split())
+                ta = len(normalized.split())
+                ratio = round(ta / tb, 4) if tb else 1.0
+                return {
+                    "ok": True, "compressed": normalized, "strategy": "normalize",
+                    "tokens_before": tb, "tokens_after": ta, "ratio": ratio,
+                    "lossy": False, "ccr_id": None,
+                    "note": " | ".join(note_parts) or None,
+                }
+
+            if mode == "aggressive":
+                note_parts.append(
+                    "aggressive mode requires daemon compress_mode=aggressive in config"
+                )
+
+            res = CompressRouter.get_instance().compress_text(content)
+
+            ccr_id = None
+            if res.lossy and reversible:
+                stored = CCRStore.get_instance().store(
+                    content.encode("utf-8"),
+                    tenant_id=_tenant(),
+                    ttl_seconds=ttl_seconds,
+                )
+                ccr_id = stored or None
+                if ccr_id:
+                    note_parts.append("reversible: call slm_retrieve with this ccr_id")
+
+            ratio = (
+                round(res.tokens_after / res.tokens_before, 4)
+                if res.tokens_before else 1.0
+            )
+            return {
+                "ok": True, "compressed": res.compressed_text, "strategy": res.strategy,
+                "tokens_before": res.tokens_before, "tokens_after": res.tokens_after,
+                "ratio": ratio, "lossy": res.lossy, "ccr_id": ccr_id,
+                "note": " | ".join(note_parts) or None,
+            }
+
+        except Exception as exc:
+            logger.error("slm_compress failed (fail-open): %s", exc)
+            t = len(content.split()) if isinstance(content, str) else 0
+            return {
+                "ok": False,
+                "compressed": content if isinstance(content, str) else "",
+                "strategy": "none", "tokens_before": t, "tokens_after": t,
+                "ratio": 1.0, "lossy": False, "ccr_id": None,
+                "note": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_retrieve(ccr_id: str) -> dict:
+        """Retrieve original text stored during a lossy slm_compress call.
+
+        Do not log or share ccr_ids — they are unguessable session tokens, but
+        if exposed they allow retrieval by anyone with the daemon's decryption key.
+
+        Args:
+            ccr_id: UUID4 returned by slm_compress when reversible=True.
+        """
+        try:
+            if not ccr_id or not _UUID4_RE.match(ccr_id):
+                return {
+                    "ok": False, "content": None, "size_bytes": 0,
+                    "error": "ccr_id must be a UUID4",
+                }
+            original = CCRStore.get_instance().retrieve(ccr_id)
+            if original is None:
+                return {
+                    "ok": False, "content": None, "size_bytes": 0,
+                    "error": "not found (expired / never stored / wrong id)",
+                }
+            size = len(original)
+            try:
+                text = original.decode("utf-8")
+            except UnicodeDecodeError:
+                text = original.decode("latin-1")
+            return {"ok": True, "content": text, "size_bytes": size, "error": None}
+
+        except Exception as exc:
+            logger.error("slm_retrieve failed (fail-open): %s", exc)
+            return {
+                "ok": False, "content": None, "size_bytes": 0,
+                "error": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def slm_cache_set(key: str, value: str, ttl_seconds: int = 86400) -> dict:
+        """Cache a result you want to reuse (tool output, file read, search result).
+
+        This caches results the agent explicitly routes through SLM — NOT the
+        Claude conversation turn (impossible without a proxy).
+
+        Do not cache secrets, credentials, or ccr_ids via this tool.
+
+        Args:
+            key: Cache key (max 512 chars). Namespaced per agent automatically.
+            value: Value to store as string (max 1MB).
+            ttl_seconds: Time-to-live in seconds (default 24h).
+        """
+        try:
+            if not key or len(key) > _MAX_KV_KEY_CHARS:
+                return {
+                    "ok": False, "stored": False,
+                    "note": f"key must be 1–{_MAX_KV_KEY_CHARS} chars",
+                }
+            value_bytes = value.encode("utf-8")
+            if len(value_bytes) > _MAX_KV_VALUE_BYTES:
+                return {"ok": False, "stored": False, "note": "value exceeds 1MB limit"}
+
+            tenant = _tenant()
+            cache_key = hashlib.sha256(f"mcpkv:{tenant}:{key}".encode()).hexdigest()
+            norm_tid = _normalize_tenant_id(tenant)
+            ttl_exp = time.time() + ttl_seconds
+
+            CacheDB.get_default().set(
+                cache_key, norm_tid, value_bytes,
+                model="mcp-kv", ttl_expires=ttl_exp, tags=["mcp-kv"],
+            )
+            return {"ok": True, "stored": True, "note": None}
+
+        except Exception as exc:
+            logger.error("slm_cache_set failed (fail-open): %s", exc)
+            return {"ok": False, "stored": False, "note": f"internal error: {exc}"}
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_cache_get(key: str) -> dict:
+        """Retrieve a previously cached result.
+
+        Returns hit:True + value if the key exists and has not expired.
+        Returns hit:False (never raises) on miss, expiry, or any error.
+
+        Args:
+            key: Cache key used in slm_cache_set.
+        """
+        global _kv_hits, _kv_misses
+        try:
+            if not key or len(key) > _MAX_KV_KEY_CHARS:
+                return {
+                    "ok": False, "hit": False, "value": None,
+                    "note": f"key must be 1–{_MAX_KV_KEY_CHARS} chars",
+                }
+            tenant = _tenant()
+            cache_key = hashlib.sha256(f"mcpkv:{tenant}:{key}".encode()).hexdigest()
+            norm_tid = _normalize_tenant_id(tenant)
+
+            blob = CacheDB.get_default().get_value(cache_key, norm_tid)
+            if blob is None:
+                with _kv_lock:
+                    _kv_misses += 1
+                return {"ok": True, "hit": False, "value": None, "note": None}
+            with _kv_lock:
+                _kv_hits += 1
+            return {"ok": True, "hit": True, "value": blob.decode("utf-8"), "note": None}
+
+        except Exception as exc:
+            logger.error("slm_cache_get failed (fail-open): %s", exc)
+            return {
+                "ok": False, "hit": False, "value": None,
+                "note": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_optimize_stats() -> dict:
+        """Return compression and cache statistics.
+
+        Proxy/compress stats are daemon-persisted (accurate across restarts).
+        KV stats are in-module counters for this MCP process session only.
+        """
+        try:
+            snap = CacheDB.get_default().metrics_load()
+            with _kv_lock:
+                kv_h = _kv_hits
+                kv_m = _kv_misses
+            return {
+                "ok": True,
+                "compress_runs": snap.compress_runs,
+                "tokens_saved_compress": snap.tokens_saved_compress,
+                "cache_proxy_hits": snap.hits,
+                "cache_proxy_misses": snap.misses,
+                "cache_kv_hits": kv_h,
+                "cache_kv_misses": kv_m,
+                "ccr_note": (
+                    "CCR entry count not tracked per-session; "
+                    "see daemon /api/v1/metrics"
+                ),
+                "note": "proxy stats are daemon-persisted; kv stats are this session only",
+            }
+        except Exception as exc:
+            logger.error("slm_optimize_stats failed (fail-open): %s", exc)
+            return {
+                "ok": False,
+                "compress_runs": 0, "tokens_saved_compress": 0,
+                "cache_proxy_hits": 0, "cache_proxy_misses": 0,
+                "cache_kv_hits": 0, "cache_kv_misses": 0,
+                "ccr_note": None,
+                "note": f"internal error: {exc}",
+            }

package/src/superlocalmemory/mesh/broker.py

@@ -281,10 +281,13 @@ class MeshBroker:
         try:
             now = datetime.now(timezone.utc).isoformat()
             # Direct messages to this peer
+            # v3.6.12 (mesh-3): only UNREAD direct messages — was returning read
+            # ones too, so every poll re-listed already-read messages until the
+            # 24h cleanup (broadcast/project already filter unread via mesh_reads).
             direct = conn.execute(
                 "SELECT id, from_peer, to_peer, msg_type, content, read, created_at, "
                 "target_type, project_path FROM mesh_messages "
-                "WHERE to_peer=? AND target_type='peer' "
+                "WHERE to_peer=? AND target_type='peer' AND COALESCE(read, 0) = 0 "
                 "AND (expires_at IS NULL OR expires_at > ?) "
                 "ORDER BY created_at DESC LIMIT 100",
                 (peer_id, now),
@@ -411,10 +414,18 @@ class MeshBroker:
                 return {"ok": True, "action": "acquired"}
 
             elif action == "release":
-                conn.execute("DELETE FROM mesh_locks WHERE file_path=? AND locked_by=?",
-                             (file_path, locked_by))
+                # v3.6.12 (mesh-2): report whether we actually released. The
+                # DELETE is correctly owner-scoped, but it previously returned
+                # released=ok:true even when a NON-owner released nothing.
+                cur = conn.execute(
+                    "DELETE FROM mesh_locks WHERE file_path=? AND locked_by=?",
+                    (file_path, locked_by),
+                )
                 conn.commit()
-                return {"ok": True, "action": "released"}
+                if cur.rowcount and cur.rowcount > 0:
+                    return {"ok": True, "action": "released"}
+                return {"ok": False, "action": "not_released",
+                        "error": "no lock held by this peer for that file"}
 
             elif action == "query":
                 row = conn.execute(

package/src/superlocalmemory/optimize/compress/router.py

@@ -317,11 +317,16 @@ class CompressRouter:
 
     @staticmethod
     def _normalize_whitespace(text: str) -> str:
-        """Layer 1 lossless: collapse excess blank lines, strip trailing spaces per line."""
+        """Layer 1 safe: collapse runs of 3+ blank lines to a single blank line.
+
+        v3.6.12 (normalize-1): no longer rstrips trailing spaces per line — that
+        is LOSSY for Markdown hard breaks (two trailing spaces) and padded string
+        literals, which broke the 'lossless/safe' guarantee that callers (incl.
+        slm_compress mode=normalize) rely on. Only collapsing excess blank lines
+        remains, which is semantically safe.
+        """
         import re
-        text = re.sub(r"\n{3,}", "\n\n", text)
-        lines = [line.rstrip() for line in text.split("\n")]
-        return "\n".join(lines)
+        return re.sub(r"\n{3,}", "\n\n", text)
 
     # ── Lazy loaders ─────────────────────────────────────────────────────
 

package/src/superlocalmemory/optimize/storage/db.py

@@ -14,7 +14,12 @@ REUSE: DatabaseManager from superlocalmemory/src/superlocalmemory/storage/databa
 ENCRYPTION (resolves SEC-C-01 / CWE-312, NEW-M-01, NEW-M-02):
   - All value BLOBs (llmcache_entries.value_blob) are AES-256-GCM encrypted.
   - CCR original_blob is ALSO AES-256-GCM encrypted.
-  - Key derivation: PBKDF2-HMAC-SHA256(password=machine_id, salt=_per_db_salt, iter=100_000)
+  - Key storage: a single MACHINE-WIDE key file (~/.superlocalmemory/opt-key.bin,
+    0o600) is generated once and reused for all cache DBs on the machine. (The
+    per-DB salt below is persisted for provenance but does NOT make the AES key
+    per-DB — a single install has one llmcache.db, so a machine-wide key is the
+    intended model. A tampered/rotated key now degrades to a cache MISS, not a
+    crash — see _decrypt fail-open, v3.6.12 cache-1.)
   - Salt: os.urandom(32) generated ONCE at DB creation, stored in
     llmcache_schema_version.description='salt:<hex>'. NO hardcoded salt.
   - Nonce (12 bytes random) prepended to each ciphertext.
@@ -43,6 +48,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from cryptography.exceptions import InvalidTag
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.hazmat.primitives import hashes
@@ -368,7 +374,15 @@ class CacheDB:
         nonce = blob[:_AES_NONCE_BYTES]
         ciphertext = blob[_AES_NONCE_BYTES:]
         aesgcm = AESGCM(self._aes_key)
-        return aesgcm.decrypt(nonce, ciphertext, associated_data=None)
+        # v3.6.12 (cache-1): AES-GCM raises cryptography.exceptions.InvalidTag
+        # (NOT a ValueError subclass) on a tampered/wrong-key blob. Every caller
+        # catches ValueError to fail-open; convert InvalidTag -> ValueError here
+        # at the single chokepoint so a corrupt/rotated-key cache entry degrades
+        # to a miss instead of raising out of get()/get_value()/ccr_get().
+        try:
+            return aesgcm.decrypt(nonce, ciphertext, associated_data=None)
+        except InvalidTag as exc:
+            raise ValueError(f"AES-GCM authentication failed: {exc}") from exc
 
     # ---- assertion ----
 
@@ -421,6 +435,30 @@ class CacheDB:
             logger.warning("CacheDB.get failed (cache miss): %s", exc)
             return None
 
+    def get_value(self, cache_key: str, tenant_id: str) -> bytes | None:
+        """Pure value lookup — no hit_count increment (unlike get()).
+
+        Used by MCP KV tools which manage their own hit/miss counters.
+        Caller must have already normalized tenant_id. Fail-open: returns None on error.
+        """
+        try:
+            rows = self._db.execute(
+                "SELECT value_blob, compressed FROM llmcache_entries "
+                "WHERE cache_key = ? AND tenant_id = ? "
+                "AND (ttl_expires IS NULL OR ttl_expires > ?) LIMIT 1",
+                (cache_key, tenant_id, time.time()),
+            )
+            if not rows:
+                return None
+            row = dict(rows[0])
+            plaintext = self._decrypt(row["value_blob"])
+            if row.get("compressed", 0):
+                plaintext = zlib.decompress(plaintext)
+            return plaintext
+        except (sqlite3.Error, ValueError, zlib.error) as exc:
+            logger.warning("CacheDB.get_value failed (fail-open): %s", exc)
+            return None
+
     def set(
         self,
         key: str,

package/src/superlocalmemory/server/api.py

@@ -108,12 +108,20 @@ def create_app() -> FastAPI:
     # Rate limiting (graceful)
     try:
         from superlocalmemory.infra.rate_limiter import RateLimiter
-        _write_limiter = RateLimiter(max_requests=30, window_seconds=60)
-        _read_limiter = RateLimiter(max_requests=120, window_seconds=60)
+        from superlocalmemory.core.remote_mode import (
+            rate_limit_config,
+            is_rate_limit_exempt,
+        )
+        # v3.6.12 (issue #40): env-tunable thresholds (defaults unchanged).
+        _rl_write, _rl_read, _rl_window = rate_limit_config()
+        _write_limiter = RateLimiter(max_requests=_rl_write, window_seconds=_rl_window)
+        _read_limiter = RateLimiter(max_requests=_rl_read, window_seconds=_rl_window)
 
         @application.middleware("http")
         async def rate_limit_middleware(request, call_next):
             client_ip = request.client.host if request.client else "unknown"
+            if is_rate_limit_exempt(client_ip):
+                return await call_next(request)
             is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
             limiter = _write_limiter if is_write else _read_limiter
             allowed, remaining = limiter.is_allowed(client_ip)
@@ -122,7 +130,7 @@ def create_app() -> FastAPI:
                 return JSONResponse(
                     status_code=429,
                     content={"error": "Too many requests."},
-                    headers={"Retry-After": str(limiter.window_seconds)},
+                    headers={"Retry-After": str(limiter.window)},
                 )
             response = await call_next(request)
             response.headers["X-RateLimit-Remaining"] = str(remaining)

package/src/superlocalmemory/server/routes/mesh.py

@@ -77,6 +77,19 @@ def _get_broker(request: Request):
     config = getattr(request.app.state, 'config', None)
     if config and not getattr(config, 'mesh_enabled', True):
         raise HTTPException(503, detail="Mesh disabled in config")
+    # v3.6.12 (mesh-1 security): SLM_MESH_SHARED_SECRET was read by the broker but
+    # never verified on inbound mesh HTTP calls. When a secret is configured,
+    # require it (constant-time) from NON-loopback callers via X-Mesh-Secret.
+    # The local MCP client always calls over loopback and is exempt, so this is
+    # zero-change for single-machine use and closes the LAN mesh auth bypass.
+    secret = getattr(broker, "_shared_secret", None)
+    if secret:
+        client_host = request.client.host if request.client else ""
+        if client_host not in ("127.0.0.1", "::1", "localhost"):
+            import hmac
+            presented = request.headers.get("x-mesh-secret", "")
+            if not hmac.compare_digest(presented, secret):
+                raise HTTPException(401, detail="invalid or missing mesh secret")
     return broker
 
 

package/src/superlocalmemory/server/routes/token.py

@@ -33,8 +33,11 @@ router = APIRouter(tags=["internal"])
 
 _ALLOWED_ORIGIN_PREFIXES = (
     "http://127.0.0.1",
+    "https://127.0.0.1",
     "http://localhost",
+    "https://localhost",
     "http://[::1]",
+    "https://[::1]",
 )
 
 
@@ -57,13 +60,22 @@ async def get_token(request: Request) -> JSONResponse:
         logger.debug("token: primitives unimportable: %s", exc)
         return JSONResponse({"error": "server_error"}, status_code=500)
 
+    # v3.6.12 (issue #39): in SLM_REMOTE mode, also serve the token to
+    # explicitly-allowlisted LAN clients so a remote-browser dashboard can load
+    # the Brain page. Default stays loopback-only — remote_mode helpers return
+    # False unless SLM_REMOTE=1 AND the client IP is in SLM_MCP_ALLOWED_HOSTS.
+    from superlocalmemory.core.remote_mode import (
+        is_lan_client_allowed,
+        is_remote_origin_allowed,
+    )
+
     client_host = request.client.host if request.client else ""
-    if not is_loopback(client_host):
+    if not is_loopback(client_host) and not is_lan_client_allowed(client_host):
         return JSONResponse({"error": "loopback only"}, status_code=403)
 
     headers = {k.lower(): v for k, v in request.headers.items()}
     origin = headers.get("origin", "")
-    if not _origin_is_loopback(origin):
+    if not _origin_is_loopback(origin) and not is_remote_origin_allowed(origin):
         return JSONResponse(
             {"error": "origin not allowed"}, status_code=403,
         )