superlocalmemory 3.6.11 → 3.6.12

package/CHANGELOG.md

@@ -5,7 +5,38 @@ 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.11] - 2026-06-14 — Optimize Everywhere: three surfaces (proxy · MCP tools · skill)
+## [3.6.12] - 2026-06-14 — Distributed-ready + stability fixes
+
+Makes SuperLocalMemory work correctly across a LAN / distributed deployment (issues #39, #40) and fixes a set of stability and security defects. Default single-machine behavior is unchanged.
+
+### Added
+
+- **`SLM_REMOTE=1` — one-switch LAN mode** (default OFF). When enabled, SLM serves the dashboard install token to allowlisted LAN clients, runs the MCP transport statelessly so a gateway/hub can forward tool calls, allows trusted LAN dashboard origins, and exempts the trusted LAN dashboard from rate limiting. LAN access stays gated by `SLM_MCP_ALLOWED_HOSTS`. Granular flags: `SLM_MCP_STATELESS=1`, and tunable rate limits `SLM_RATE_LIMIT_WRITE` / `SLM_RATE_LIMIT_READ` / `SLM_RATE_LIMIT_WINDOW`. See `docs/distributed-deployment.md`.
+- **`slm search`** CLI command (parity with the MCP `search` tool).
+
+### Fixed — Distributed / LAN (#39, #40)
+
+- **The Brain page now loads from a remote browser** on the LAN (the install-token endpoint serves allowlisted LAN clients in remote mode instead of being loopback-only).
+- **Mesh tools no longer fail with `-32600 Session not found`** when called through an MCP gateway/hub (the transport can now run stateless so the session id need not be replayed).
+- **Custom LLM endpoints (llama.cpp / LM Studio / Azure) can now be configured from the dashboard** — the Settings page shows, sends, and saves the endpoint, and switching mode actually persists.
+- **The dashboard rate limit (`429 Too Many Requests`) is now configurable** and trusted LAN clients are exempt in remote mode.
+
+### Fixed — Stability & security
+
+- **Authentication now fails closed.** A failure to install the auth gate could previously leave write endpoints unauthenticated; it now logs and denies non-loopback writes instead.
+- **Mesh peer registration fixed** — sessions now register with the correct peer id, so heartbeat, direct messages, and inbox work reliably (previously they could silently target a non-existent peer).
+- **`SLM_MESH_SHARED_SECRET` is now enforced** on inbound mesh requests from non-loopback callers.
+- **The cache no longer raises on a corrupted or wrong-key entry** — it degrades to a cache miss.
+- **SSRF protection** added to the provider connection test (cloud-metadata and internal addresses are blocked for remote callers; the local dashboard can still test local/LAN endpoints).
+- **Mode B no longer silently falls back to Mode A** when using a keyless local LLM endpoint.
+- **Memory search no longer errors on punctuation** (`?`, `-`, quotes, etc.).
+- **Mode B honors the configured LLM endpoint and timeout** in summarization and consolidation (previously hardcoded to localhost).
+- **Math-health dashboard reports real status** instead of always showing green.
+- Mesh lock release and inbox now behave correctly (no false success, no re-listing of already-read messages); switching profile takes effect immediately for recall.
+
+### Removed
+
+- Removed legacy dead code (an unused in-process daemon handler and superseded duplicate API routes) for a cleaner, more maintainable codebase. No functional change. — Optimize Everywhere: three surfaces (proxy · MCP tools · skill)
 
 Cache + compress across **every setup** — proxy, MCP tools, or skill. Five new MCP tools land directly inside `slm mcp` (no proxy, full 1M context window preserved). A new `slm-optimize` skill makes compression and routed-result caching zero-config for Claude Code users. Overclaim in prior docs fixed; three-surfaces table added.
 

package/README.md

@@ -35,6 +35,8 @@
 
 > V3.6 is the only local-first layer that SKIPS repeat LLM calls (cache: 100% on a hit), SHRINKS tool outputs and injected context (compress: lossless-by-default, opt-in LLMLingua-2), and DISCOUNTS prefix costs (align: native KV-cache) — and remembers everything — in one install.
 >
+> **v3.6.12 "Distributed-ready":** Run SLM on a server and reach it across your LAN. `SLM_REMOTE=1` (default off) lets the dashboard load from a remote browser, lets MCP gateways/hubs forward tool calls, and makes custom local LLM endpoints (llama.cpp / LM Studio / Azure) configurable right from the dashboard — plus a batch of stability and security fixes. See [`docs/distributed-deployment.md`](docs/distributed-deployment.md).
+>
 > **v3.6.11 "Optimize Everywhere":** Three surfaces. **Proxy** (Surface A) — full-turn cache + compress on transport; needs `ANTHROPIC_BASE_URL`, shrinks the context window. **MCP tools** (Surface B) — `slm_compress`, `slm_retrieve`, `slm_cache_set`, `slm_cache_get`, `slm_optimize_stats`; no proxy, no window shrink, works on any Claude subscription. **Skill** (Surface C) — `slm-optimize` installs in `~/.claude/skills/`; zero-config auto-compress for large tool outputs and CLAUDE.md. No proxy, full 1M window. [See Three Surfaces →](#three-surfaces-proxy--mcp-tools--skill)
 >
 > **v3.6.10:** cache and compression are now **independent runtime switches** (cache-only, compress-only, both, or neither — toggle live from the dashboard, no restart). Compression was rebuilt to be **lossless by default** (the old string/array/code truncation is gone); aggressive mode adds LLMLingua-2 for **prose only** — never code, numbers, structured data, or the current turn.

package/package.json

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

package/src/superlocalmemory/cli/commands.py

@@ -114,6 +114,7 @@ def dispatch(args: Namespace) -> None:
         "list": cmd_list,
         "remember": cmd_remember,
         "recall": cmd_recall,
+        "search": cmd_recall,  # v3.6.12 (parity-3): MCP exposes a `search` verb; give the CLI parity (recall is multi-channel incl. BM25/keyword).
         "forget": cmd_forget,
         "delete": cmd_delete,
         "update": cmd_update,

package/src/superlocalmemory/cli/daemon.py

@@ -408,410 +408,3 @@ def _wait_for_workers_dead(timeout: int = 10) -> None:
         time.sleep(0.5)
 
     logger.warning("Some SLM workers still alive after %ds timeout", timeout)
-
-
-# ---------------------------------------------------------------------------
-# Server: HTTP request handler with engine singleton
-# ---------------------------------------------------------------------------
-
-_engine = None
-_last_activity = time.monotonic()
-
-# ---------------------------------------------------------------------------
-# V3.3.28: Observation debounce buffer.
-#
-# When 20+ file edits arrive in quick succession (from parallel AI agents,
-# git checkout, or batch sed), we buffer observations for _OBSERVE_DEBOUNCE_SEC
-# seconds and deduplicate by content hash. This reduces 20 observations → 1-3
-# batches, each processed by the singleton engine (1 embedding worker).
-# ---------------------------------------------------------------------------
-
-_OBSERVE_DEBOUNCE_SEC = float(os.environ.get("SLM_OBSERVE_DEBOUNCE_SEC", "3.0"))
-_observe_buffer: list[str] = []
-_observe_seen: set[str] = set()  # content hashes for dedup within window
-_observe_lock = threading.Lock()
-_observe_timer: threading.Timer | None = None
-
-
-def _flush_observe_buffer() -> None:
-    """Process all buffered observations as a single batch."""
-    global _observe_timer
-    with _observe_lock:
-        if not _observe_buffer:
-            return
-        batch = list(_observe_buffer)
-        _observe_buffer.clear()
-        _observe_seen.clear()
-        _observe_timer = None
-
-    # Process each unique observation (already deduped)
-    engine = _get_engine()
-    from superlocalmemory.hooks.auto_capture import AutoCapture
-    auto = AutoCapture(engine=engine)
-
-    for content in batch:
-        try:
-            decision = auto.evaluate(content)
-            if decision.capture:
-                auto.capture(content, category=decision.category)
-        except Exception as exc:
-            # Swallow per-observation to protect the batch, but log so
-            # a pattern of dropped observations is visible.
-            logger.warning("observation dropped during batch: %s", exc)
-
-    logger.info("Observe debounce: processed %d observations (from buffer)", len(batch))
-
-
-def _enqueue_observation(content: str) -> dict:
-    """Add an observation to the debounce buffer. Returns immediate response."""
-    global _observe_timer
-    import hashlib
-    content_hash = hashlib.md5(content.encode()).hexdigest()
-
-    with _observe_lock:
-        if content_hash in _observe_seen:
-            return {"captured": False, "reason": "duplicate within debounce window"}
-
-        _observe_seen.add(content_hash)
-        _observe_buffer.append(content)
-        buf_size = len(_observe_buffer)
-
-        # Reset debounce timer
-        if _observe_timer is not None:
-            _observe_timer.cancel()
-        _observe_timer = threading.Timer(_OBSERVE_DEBOUNCE_SEC, _flush_observe_buffer)
-        _observe_timer.daemon = True
-        _observe_timer.start()
-
-    return {"captured": True, "queued": True, "buffer_size": buf_size,
-            "debounce_sec": _OBSERVE_DEBOUNCE_SEC}
-
-
-def _get_engine():
-    global _engine
-    if _engine is None:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.core.engine import MemoryEngine
-
-        config = SLMConfig.load()
-        _engine = MemoryEngine(config)
-        _engine.initialize()
-
-        # Force reranker warmup (blocking — daemon can afford to wait)
-        retrieval_eng = getattr(_engine, '_retrieval_engine', None)
-        if retrieval_eng:
-            reranker = getattr(retrieval_eng, '_reranker', None)
-            if reranker and hasattr(reranker, 'warmup_sync'):
-                reranker.warmup_sync(timeout=120)
-
-        logger.info("Daemon engine initialized and warm")
-    return _engine
-
-
-class DaemonHandler(BaseHTTPRequestHandler):
-    """Lightweight HTTP handler for daemon requests."""
-
-    def log_message(self, format, *args):
-        """Suppress default access logging."""
-        pass
-
-    def _send_json(self, status: int, data: dict) -> None:
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json")
-        self.end_headers()
-        self.wfile.write(json.dumps(data).encode())
-
-    def _read_body(self) -> dict:
-        length = int(self.headers.get("Content-Length", 0))
-        if length == 0:
-            return {}
-        return json.loads(self.rfile.read(length).decode())
-
-    def do_GET(self) -> None:
-        global _last_activity
-        _last_activity = time.monotonic()
-
-        if self.path == "/health":
-            self._send_json(200, {"status": "ok", "pid": os.getpid()})
-            return
-
-        if self.path.startswith("/recall"):
-            try:
-                # Parse query from URL params
-                from urllib.parse import urlparse, parse_qs
-                params = parse_qs(urlparse(self.path).query)
-                query = params.get("q", [""])[0]
-                limit = int(params.get("limit", ["20"])[0])
-
-                # S9-DASH-02: session_id for outcome-queue enqueue.
-                # Priority: ?session_id= query arg > X-SLM-Session-Id
-                # header > synthetic "cli:<ts>". Without any of these
-                # the recall still works — it just doesn't produce a
-                # pending_outcome (hook-based signals can't match).
-                session_id = params.get("session_id", [""])[0]
-                if not session_id:
-                    session_id = self.headers.get("X-SLM-Session-Id", "")
-                if not session_id:
-                    import time as _t
-                    session_id = f"http:{int(_t.time() * 1000)}"
-
-                engine = _get_engine()
-                raw_fast = params.get("fast", ["false"])[0]
-                fast = raw_fast.lower() in ("true", "1")
-                response = engine.recall(
-                    query, limit=limit, session_id=session_id, fast=fast,
-                )
-                # Return the same field shape as recall_worker._handle_recall,
-                # so MCP processes that proxy through the daemon get recall_trace-
-                # compatible data without a second round trip.
-                memory_ids = list({
-                    r.fact.memory_id for r in response.results[:limit]
-                    if r.fact.memory_id
-                })
-                memory_map = (
-                    engine._db.get_memory_content_batch(memory_ids)
-                    if memory_ids else {}
-                )
-                results = []
-                for r in response.results[:limit]:
-                    fact_type = getattr(r.fact, "fact_type", None)
-                    lifecycle = getattr(r.fact, "lifecycle", None)
-                    # v3.5.1: sanitize control chars that break JSON (newlines, tabs in content).
-                    clean = r.fact.content.replace("\r", " ").replace("\n", " ").replace("\t", " ")
-                    sc_raw = memory_map.get(r.fact.memory_id, "")
-                    sc_clean = sc_raw.replace("\r", " ").replace("\n", " ").replace("\t", " ") if sc_raw else ""
-                    results.append({
-                        "fact_id": r.fact.fact_id,
-                        "memory_id": r.fact.memory_id,
-                        "content": clean,
-                        "source_content": sc_clean,
-                        "score": round(r.score, 4),
-                        "confidence": round(r.confidence, 4),
-                        "trust_score": round(r.trust_score, 4),
-                        "channel_scores": {
-                            k: round(v, 4)
-                            for k, v in (r.channel_scores or {}).items()
-                        },
-                        "fact_type": fact_type.value
-                            if fact_type and hasattr(fact_type, "value") else "",
-                        "lifecycle": lifecycle.value
-                            if lifecycle and hasattr(lifecycle, "value") else "",
-                        "access_count": getattr(r.fact, "access_count", 0),
-                        "evidence_chain": list(
-                            getattr(r, "evidence_chain", []) or []
-                        ),
-                    })
-                self._send_json(200, {
-                    "ok": True,
-                    "query": query,
-                    "query_type": response.query_type,
-                    "result_count": len(results),
-                    "retrieval_time_ms": round(response.retrieval_time_ms, 1),
-                    "channel_weights": {
-                        k: round(v, 3)
-                        for k, v in (response.channel_weights or {}).items()
-                    },
-                    "total_candidates": getattr(response, "total_candidates", 0),
-                    "results": results,
-                    "count": len(results),  # backward compat alias
-                })
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/list":
-            try:
-                engine = _get_engine()
-                facts = engine.list_facts(limit=50)
-                items = [
-                    {"content": f.content[:100], "fact_type": getattr(f.fact_type, 'value', str(f.fact_type)),
-                     "created_at": (f.created_at or "")[:19], "fact_id": f.fact_id}
-                    for f in facts
-                ]
-                self._send_json(200, {"results": items, "count": len(items)})
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/status":
-            engine = _get_engine()
-            uptime = time.monotonic() - _server_start_time
-            self._send_json(200, {
-                "status": "running", "pid": os.getpid(),
-                "uptime_s": round(uptime),
-                "mode": engine._config.mode.value,
-                "fact_count": engine.fact_count,
-                "idle_s": round(time.monotonic() - _last_activity),
-            })
-            return
-
-        self._send_json(404, {"error": "not found"})
-
-    def do_POST(self) -> None:
-        global _last_activity
-        _last_activity = time.monotonic()
-
-        if self.path == "/remember":
-            try:
-                body = self._read_body()
-                content = body.get("content", "")
-                tags = body.get("tags", "")
-                extra_meta = body.get("metadata") or {}
-                if not content:
-                    self._send_json(400, {"error": "content required"})
-                    return
-
-                engine = _get_engine()
-                metadata = {"tags": tags} if tags else {}
-                if isinstance(extra_meta, dict):
-                    metadata.update(extra_meta)
-                fact_ids = engine.store(content, metadata=metadata)
-                self._send_json(200, {
-                    "ok": True,
-                    "fact_ids": fact_ids,
-                    "count": len(fact_ids),
-                })
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/observe":
-            try:
-                body = self._read_body()
-                content = body.get("content", "")
-                if not content:
-                    self._send_json(400, {"error": "content required"})
-                    return
-
-                # V3.3.28: Debounced observation processing.
-                # Buffers observations for 3s, deduplicates, processes as batch.
-                # Returns immediately — the actual capture happens asynchronously
-                # via the debounce timer, using the singleton engine.
-                result = _enqueue_observation(content)
-                self._send_json(200, result)
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/stop":
-            self._send_json(200, {"status": "stopping"})
-            Thread(target=_shutdown_server, daemon=True).start()
-            return
-
-        self._send_json(404, {"error": "not found"})
-
-
-# ---------------------------------------------------------------------------
-# Server lifecycle
-# ---------------------------------------------------------------------------
-
-_server: HTTPServer | None = None
-_server_start_time = time.monotonic()
-
-
-def _shutdown_server() -> None:
-    global _engine, _server
-    try:
-        _flush_observe_buffer()
-    except Exception as exc:
-        logger.warning("flush observe buffer on shutdown failed: %s", exc)
-    time.sleep(0.5)
-    if _engine is not None:
-        try:
-            _engine.close()
-        except Exception as exc:
-            logger.warning("engine close on shutdown failed: %s", exc)
-        _engine = None
-    if _server is not None:
-        _server.shutdown()
-    _PID_FILE.unlink(missing_ok=True)
-    _PORT_FILE.unlink(missing_ok=True)
-
-
-def _idle_watchdog(timeout: int) -> None:
-    """Auto-shutdown after idle timeout."""
-    global _last_activity
-    while True:
-        time.sleep(30)
-        idle = time.monotonic() - _last_activity
-        if idle > timeout:
-            logger.info("Daemon idle for %ds, shutting down", int(idle))
-            _shutdown_server()
-            os._exit(0)
-
-
-def start_server(port: int = _DEFAULT_PORT, idle_timeout: int | None = None) -> None:
-    """Start the daemon HTTP server. Blocks until stopped."""
-    global _server, _server_start_time, _last_activity
-
-    idle_timeout = idle_timeout or int(os.environ.get(
-        "SLM_DAEMON_IDLE_TIMEOUT", str(_DEFAULT_IDLE_TIMEOUT),
-    ))
-
-    # Banner is advisory — a broken data dir must never prevent the daemon
-    # from starting, so the swallow here is intentional.
-    try:
-        from superlocalmemory import __version__ as _slm_ver
-        from superlocalmemory.cli.version_banner import check_and_emit_upgrade_banner
-        check_and_emit_upgrade_banner(_slm_ver)
-    except Exception as exc:
-        logger.warning("upgrade banner on daemon start failed: %s", exc)
-
-    # Apply the v3.4.26 data-dir migration now — the daemon is the
-    # authoritative holder of the DB, so this is the right place to do
-    # it unconditionally (``migrate`` is idempotent).
-    try:
-        from pathlib import Path as _P
-        from superlocalmemory.migrations.v3_4_25_to_v3_4_26 import (
-            is_ready as _is_ready, migrate as _migrate,
-        )
-        _data = _P(os.environ.get("SLM_DATA_DIR")
-                   or _P.home() / ".superlocalmemory")
-        if not _is_ready(_data):
-            _migrate(_data)
-    except Exception as exc:
-        logger.warning("v3.4.26 migration on daemon start failed: %s", exc)
-
-    # Write PID + port files
-    _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
-    _PID_FILE.write_text(str(os.getpid()))
-    _PORT_FILE.write_text(str(port))
-
-    # Handle SIGTERM for graceful shutdown
-    signal.signal(signal.SIGTERM, lambda *_: _shutdown_server() or os._exit(0))
-
-    # Pre-warm engine (this is the cold start — daemon absorbs it once)
-    logger.info("Daemon starting — warming engine...")
-    _get_engine()
-    logger.info("Engine warm. Daemon ready on port %d (idle timeout: %ds)", port, idle_timeout)
-
-    _server_start_time = time.monotonic()
-    _last_activity = time.monotonic()
-
-    # Start idle watchdog
-    Thread(target=_idle_watchdog, args=(idle_timeout,), daemon=True, name="idle-watchdog").start()
-
-    # Start HTTP server
-    # SO_REUSEADDR must be set on the class BEFORE __init__ calls bind()
-    HTTPServer.allow_reuse_address = True
-    _server = HTTPServer(("127.0.0.1", port), DaemonHandler)
-    try:
-        _server.serve_forever()
-    except KeyboardInterrupt:
-        pass
-    finally:
-        _shutdown_server()
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
-    if "--start" in sys.argv:
-        start_server()
-    elif "--stop" in sys.argv:
-        stop_daemon()
-    else:
-        print("Usage: python -m superlocalmemory.cli.daemon --start|--stop")

package/src/superlocalmemory/cli/main.py

@@ -183,7 +183,9 @@ def main() -> None:
         help="Wait for completion (default: async background processing)",
     )
 
-    recall_p = sub.add_parser("recall", help="Semantic search with 4-channel retrieval")
+    # v3.6.12 (parity-3): `search` is an alias of `recall` so the CLI has the
+    # same search verb the MCP exposes (handlers dict maps both to cmd_recall).
+    recall_p = sub.add_parser("recall", aliases=["search"], help="Semantic search with 4-channel retrieval")
     recall_p.add_argument("query", help="Search query")
     recall_p.add_argument("--limit", type=int, default=10, help="Max results (default 10)")
     recall_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")

package/src/superlocalmemory/core/context_cache.py

@@ -205,7 +205,10 @@ class ContextCache:
         Does NOT run LRU sweep inline (PERF-01-07) — that's a background
         task on the daemon.
         """
-        content = redact_secrets(entry.content)[:MAX_CONTENT_CHARS]
+        # v3.6.12 (redact-1): scrub dashboard/cached content at HIGH aggression
+        # so Bearer/GitHub-PAT/Anthropic/OpenAI/GENERIC_KEY patterns are caught
+        # (the default 'normal' skipped them, leaking those shapes to the UI).
+        content = redact_secrets(entry.content, aggression="high")[:MAX_CONTENT_CHARS]
         fact_ids_json = json.dumps(list(entry.fact_ids))
         byte_size = (
             len(content.encode("utf-8"))

package/src/superlocalmemory/core/fact_consolidator.py

@@ -367,7 +367,10 @@ def _summarize_with_ollama(
         if config and hasattr(config, 'llm'):
             api_base = getattr(config.llm, 'api_base', api_base) or api_base
             model = getattr(config.llm, 'model', model) or model
-            timeout = getattr(config.llm, 'timeout', timeout) or timeout
+            # v3.6.12 (modeb-4): the LLMConfig field is `timeout_seconds`, not
+            # `timeout` — the old read always missed and silently used 30s.
+            timeout = getattr(config.llm, 'timeout_seconds', None) or \
+                getattr(config.llm, 'timeout', None) or timeout
 
         fact_texts = "\n".join(f"- {f['content']}" for f in facts[:_MAX_CLUSTER_SIZE])
         prompt = (