superlocalmemory 3.6.6__tar.gz → 3.6.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.6.6
+Version: 3.6.8
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -401,6 +401,32 @@ slm status
 
 ### MCP Integration (Claude, Cursor, Windsurf, VS Code, etc.)
 
+SLM supports **two MCP transports** — use whichever fits your tool. Both expose the same 33 tools and 7 resources.
+
+#### Option A — HTTP transport (v3.6.7+, recommended)
+
+One shared process handles every client. RAM is flat regardless of how many IDE windows, subagents, or concurrent sessions connect. Requires the SLM daemon to be running (`slm start`).
+
+```json
+{
+  "mcpServers": {
+    "superlocalmemory": {
+      "type": "http",
+      "url": "http://127.0.0.1:8765/mcp/"
+    }
+  }
+}
+```
+
+> **Claude Code** also accepts:
+> ```bash
+> claude mcp add --transport http superlocalmemory http://127.0.0.1:8765/mcp/
+> ```
+
+#### Option B — stdio transport (universal, works everywhere)
+
+Spawns one `slm mcp` subprocess per client connection (~90–110 MB each). Works with every MCP-compatible tool including those that do not yet support HTTP transport. No daemon required.
+
 ```json
 {
   "mcpServers": {
@@ -412,7 +438,36 @@ slm status
 }
 ```
 
-33 MCP tools by default (+42 optional behind `SLM_MCP_ALL_TOOLS=1`) + 7 resources. Works with any MCP-compatible client — we ship templated configs for Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and Antigravity (15 IDE configs in `ide/configs/`). **V3.3: Adaptive lifecycle, smart compression, and pattern learning.**
+#### Option C — `mcp-remote` bridge (for stdio-only tools that want HTTP)
+
+Some CLIs (e.g. Grok CLI) only speak stdio but you still want the RAM benefit of HTTP. The [`@modelcontextprotocol/client-cli`](https://www.npmjs.com/package/@modelcontextprotocol/client-cli) package bridges them:
+
+```bash
+npm install -g @modelcontextprotocol/client-cli
+```
+
+```json
+{
+  "mcpServers": {
+    "superlocalmemory": {
+      "command": "mcp-remote",
+      "args": ["http://127.0.0.1:8765/mcp/", "--allow-http", "--transport", "http-only"]
+    }
+  }
+}
+```
+
+#### When to use which
+
+| Situation | Use |
+|-----------|-----|
+| Claude Code / Claude Desktop (v3.6.7+) | **HTTP** — zero new processes per session |
+| Cursor, Windsurf, Gemini CLI, Antigravity | **HTTP** — native support |
+| Grok CLI, tools that only support stdio | **`mcp-remote` bridge** |
+| Offline / daemon-free usage | **stdio** |
+| Any tool, any version | **stdio** always works as fallback |
+
+See [`docs/ide-setup.md`](docs/ide-setup.md) for per-IDE configs. 33 MCP tools by default (+42 optional behind `SLM_MCP_ALL_TOOLS=1`) + 7 resources. Works with any MCP-compatible client — we ship templated configs for Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and Antigravity (15 IDE configs in `ide/configs/`).
 
 ### Dual Interface: MCP + CLI
 

{superlocalmemory-3.6.6 → superlocalmemory-3.6.8}/README.md

@@ -309,6 +309,32 @@ slm status
 
 ### MCP Integration (Claude, Cursor, Windsurf, VS Code, etc.)
 
+SLM supports **two MCP transports** — use whichever fits your tool. Both expose the same 33 tools and 7 resources.
+
+#### Option A — HTTP transport (v3.6.7+, recommended)
+
+One shared process handles every client. RAM is flat regardless of how many IDE windows, subagents, or concurrent sessions connect. Requires the SLM daemon to be running (`slm start`).
+
+```json
+{
+  "mcpServers": {
+    "superlocalmemory": {
+      "type": "http",
+      "url": "http://127.0.0.1:8765/mcp/"
+    }
+  }
+}
+```
+
+> **Claude Code** also accepts:
+> ```bash
+> claude mcp add --transport http superlocalmemory http://127.0.0.1:8765/mcp/
+> ```
+
+#### Option B — stdio transport (universal, works everywhere)
+
+Spawns one `slm mcp` subprocess per client connection (~90–110 MB each). Works with every MCP-compatible tool including those that do not yet support HTTP transport. No daemon required.
+
 ```json
 {
   "mcpServers": {
@@ -320,7 +346,36 @@ slm status
 }
 ```
 
-33 MCP tools by default (+42 optional behind `SLM_MCP_ALL_TOOLS=1`) + 7 resources. Works with any MCP-compatible client — we ship templated configs for Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and Antigravity (15 IDE configs in `ide/configs/`). **V3.3: Adaptive lifecycle, smart compression, and pattern learning.**
+#### Option C — `mcp-remote` bridge (for stdio-only tools that want HTTP)
+
+Some CLIs (e.g. Grok CLI) only speak stdio but you still want the RAM benefit of HTTP. The [`@modelcontextprotocol/client-cli`](https://www.npmjs.com/package/@modelcontextprotocol/client-cli) package bridges them:
+
+```bash
+npm install -g @modelcontextprotocol/client-cli
+```
+
+```json
+{
+  "mcpServers": {
+    "superlocalmemory": {
+      "command": "mcp-remote",
+      "args": ["http://127.0.0.1:8765/mcp/", "--allow-http", "--transport", "http-only"]
+    }
+  }
+}
+```
+
+#### When to use which
+
+| Situation | Use |
+|-----------|-----|
+| Claude Code / Claude Desktop (v3.6.7+) | **HTTP** — zero new processes per session |
+| Cursor, Windsurf, Gemini CLI, Antigravity | **HTTP** — native support |
+| Grok CLI, tools that only support stdio | **`mcp-remote` bridge** |
+| Offline / daemon-free usage | **stdio** |
+| Any tool, any version | **stdio** always works as fallback |
+
+See [`docs/ide-setup.md`](docs/ide-setup.md) for per-IDE configs. 33 MCP tools by default (+42 optional behind `SLM_MCP_ALL_TOOLS=1`) + 7 resources. Works with any MCP-compatible client — we ship templated configs for Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and Antigravity (15 IDE configs in `ide/configs/`).
 
 ### Dual Interface: MCP + CLI
 

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

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

{superlocalmemory-3.6.6 → superlocalmemory-3.6.8}/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.6"
+__version__ = "3.6.8"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.6.6 → superlocalmemory-3.6.8}/src/superlocalmemory/mcp/server.py

@@ -237,8 +237,19 @@ def _eager_warmup() -> None:
         _logger.warning("Mesh auto-register failed: %s", exc)
 
 import threading
-_warmup_thread = threading.Thread(target=_eager_warmup, daemon=True, name="mcp-warmup")
-_warmup_thread.start()
+
+# v3.6.7: Suppress standalone-process behaviours when the MCP server is
+# imported inside the daemon (SLM_MCP_EMBEDDED=1). Three threads are safe
+# to run in a dedicated `slm mcp` subprocess but harmful inside the daemon:
+#   mcp-warmup      — creates a LIGHT engine duplicate; daemon has a FULL one.
+#   parent-watchdog — calls os._exit(0) if its parent IDE quits, which would
+#                     kill the daemon along with it.
+#   stdin-eof-monitor — monitors stdin pipe; meaningless inside the daemon.
+_embedded_in_daemon = _os.environ.get("SLM_MCP_EMBEDDED") == "1"
+
+if not _embedded_in_daemon:
+    _warmup_thread = threading.Thread(target=_eager_warmup, daemon=True, name="mcp-warmup")
+    _warmup_thread.start()
 
 
 # V3.4.57: Parent watchdog — self-terminate when the IDE/Claude session dies.
@@ -274,8 +285,9 @@ def _parent_watchdog() -> None:
             pass  # Transient errors — keep watching
 
 
-_watchdog_thread = threading.Thread(target=_parent_watchdog, daemon=True, name="parent-watchdog")
-_watchdog_thread.start()
+if not _embedded_in_daemon:
+    _watchdog_thread = threading.Thread(target=_parent_watchdog, daemon=True, name="parent-watchdog")
+    _watchdog_thread.start()
 
 
 # V3.5.9: Stdin EOF monitor — complements the parent watchdog for the case where
@@ -337,8 +349,9 @@ def _stdin_eof_monitor() -> None:
         _mlog.debug("stdin EOF monitor error: %s — watchdog will cover", exc)
 
 
-_stdin_monitor_thread = threading.Thread(target=_stdin_eof_monitor, daemon=True, name="stdin-eof-monitor")
-_stdin_monitor_thread.start()
+if not _embedded_in_daemon:
+    _stdin_monitor_thread = threading.Thread(target=_stdin_eof_monitor, daemon=True, name="stdin-eof-monitor")
+    _stdin_monitor_thread.start()
 
 
 if __name__ == "__main__":

superlocalmemory-3.6.8/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,
+    }

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

@@ -34,11 +34,17 @@ import signal
 import sys
 import threading
 import time
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, AsyncExitStack
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
+# v3.6.7: Tell mcp/server.py it is being imported inside the daemon process.
+# This suppresses the three side-effect threads (mcp-warmup, parent-watchdog,
+# stdin-eof-monitor) that are harmful when the MCP server runs embedded.
+# Must be set BEFORE any import of superlocalmemory.mcp.server.
+os.environ.setdefault("SLM_MCP_EMBEDDED", "1")
+
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
@@ -677,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).
@@ -850,7 +875,20 @@ async def lifespan(application: FastAPI):
     except Exception as e:
         logger.warning("optimize module not available: %s", e)
 
-    yield
+    # v3.6.7: Start MCP Streamable-HTTP session manager (GOTCHA #1).
+    # streamable_http_app() carries its own Starlette lifespan that initialises
+    # an anyio task group inside the session manager. Without entering that
+    # 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.
+    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)")
+
+        yield
 
     # Cancel optimize metrics flush loop + run final flush before shutdown
     try:
@@ -949,6 +987,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:
@@ -1149,6 +1195,28 @@ def create_app() -> FastAPI:
     # -- Daemon-specific routes --
     _register_daemon_routes(application)
 
+    # -- v3.6.7: MCP Streamable-HTTP transport at /mcp --
+    # Mount the FastMCP server as a Starlette ASGI sub-app so ALL clients
+    # (Claude Code sessions, subagents, desktop, hermes) share ONE daemon
+    # process instead of spawning an `slm mcp` subprocess per connection.
+    # The session manager lifespan is started in lifespan() via AsyncExitStack.
+    # Fail-open: if import or mount fails, stdio transport keeps working.
+    #
+    # streamable_http_path is set to "/" so that when mounted at "/mcp" the
+    # effective user-facing endpoint is exactly http://127.0.0.1:8765/mcp.
+    # (FastAPI strips the mount prefix before passing the request to the
+    # sub-app, so the sub-app's internal route must be "/".)
+    try:
+        from superlocalmemory.mcp.server import server as _mcp_fastmcp
+        _mcp_fastmcp.settings.streamable_http_path = "/"
+        _mcp_fastmcp._session_manager = None  # Defensive reset for idempotency
+        global _mcp_app
+        _mcp_app = _mcp_fastmcp.streamable_http_app()
+        application.mount("/mcp", _mcp_app)
+        logger.info("MCP HTTP transport mounted at /mcp (Streamable HTTP, port 8765)")
+    except Exception as _mcp_exc:  # pragma: no cover — defensive
+        logger.warning("MCP HTTP mount failed (non-fatal, stdio still works): %s", _mcp_exc)
+
     return application
 
 
@@ -1202,7 +1270,9 @@ def _register_dashboard_routes(application: FastAPI) -> None:
         # for Gemini), never X-SLM-API-Key. Verified: auth_middleware.py:50-82
         # returns False for POST when api_key file exists and X-SLM-API-Key
         # is absent.
-        _AUTH_EXEMPT_PREFIXES = ("/v1/", "/v1beta/")
+        # v3.6.7: /mcp is also exempt — MCP clients negotiate their own session
+        # via the MCP protocol; they have no knowledge of X-SLM-API-Key.
+        _AUTH_EXEMPT_PREFIXES = ("/v1/", "/v1beta/", "/mcp")
 
         @application.middleware("http")
         async def auth_middleware(request, call_next):
@@ -1536,6 +1606,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(),
@@ -1544,6 +1621,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")
@@ -1820,6 +1900,10 @@ def _update_activity():
 
 _start_time: float | None = None
 
+# v3.6.7: Starlette app returned by mcp_server.streamable_http_app().
+# Set in create_app(); consumed by lifespan() to start the session manager.
+_mcp_app = None
+
 
 # ---------------------------------------------------------------------------
 # Server entry point