superlocalmemory 3.4.24 → 3.4.30

package/src/superlocalmemory/hooks/auto_capture.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import logging
 import re
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Callable
 
 logger = logging.getLogger(__name__)
 
@@ -41,10 +41,25 @@ class CaptureDecision:
 
 
 class AutoCapture:
-    """Detect and classify content for automatic storage."""
-
-    def __init__(self, engine=None, config: dict | None = None):
+    """Detect and classify content for automatic storage.
+
+    Two ways to wire the store side:
+
+    - Pass ``engine=<MemoryEngine>`` (CLI/daemon path — historical shape).
+    - Pass ``store_fn=<callable>`` (MCP/LIGHT path — the callable should
+      match ``MemoryEngine.store(content, metadata=...)`` and return a
+      list of fact ids). When both are supplied, ``store_fn`` wins.
+    """
+
+    def __init__(
+        self,
+        engine=None,
+        config: dict | None = None,
+        *,
+        store_fn: Callable[..., Any] | None = None,
+    ):
         self._engine = engine
+        self._store_fn = store_fn
         self._config = config or {}
         self._enabled = self._config.get("enabled", True)
         self._min_confidence = self._config.get("min_confidence", 0.5)
@@ -85,18 +100,25 @@ class AutoCapture:
         return CaptureDecision(False, 0.0, "none", "no patterns matched")
 
     def capture(self, content: str, category: str = "", metadata: dict | None = None) -> bool:
-        """Store content via engine if auto-capture decides to."""
-        if not self._engine:
+        """Store content via engine or store_fn if auto-capture decides to.
+
+        Never mutates the caller's metadata dict — we copy before adding
+        our auto-capture bookkeeping keys. This matters because
+        ``pool_store`` ships the dict cross-process and callers often
+        reuse the same dict across captures.
+        """
+        if self._store_fn is None and self._engine is None:
             return False
 
         try:
-            meta = metadata or {}
-            meta["source"] = "auto-capture"
-            meta["category"] = category
-            fact_ids = self._engine.store(content, metadata=meta)
-            return len(fact_ids) > 0
+            meta = {**(metadata or {}), "source": "auto-capture", "category": category}
+            if self._store_fn is not None:
+                fact_ids = self._store_fn(content, metadata=meta)
+            else:
+                fact_ids = self._engine.store(content, metadata=meta)
+            return bool(fact_ids) and len(fact_ids) > 0
         except Exception as exc:
-            logger.debug("Auto-capture store failed: %s", exc)
+            logger.warning("Auto-capture store failed: %s", exc)
             return False
 
     def _match_patterns(self, content: str, patterns: list[str]) -> float:

package/src/superlocalmemory/hooks/auto_recall.py

@@ -7,7 +7,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import Any, Callable
 
 logger = logging.getLogger(__name__)
 
@@ -17,30 +17,53 @@ class AutoRecall:
 
     Called at session start or before each prompt to inject
     relevant memories without user intervention.
+
+    Two ways to wire the recall side:
+
+    - Pass ``engine=<MemoryEngine>`` (CLI/daemon path — historical shape).
+    - Pass ``recall_fn=<callable>`` (MCP/LIGHT path — the callable adapts
+      a worker-pool call to the ``RecallResponse``-shaped return value).
+      When both are supplied, ``recall_fn`` wins.
     """
 
-    def __init__(self, engine=None, config: dict | None = None):
+    def __init__(
+        self,
+        engine=None,
+        config: dict | None = None,
+        *,
+        recall_fn: Callable[..., Any] | None = None,
+    ):
         self._engine = engine
+        self._recall_fn = recall_fn
         self._config = config or {}
         self._enabled = self._config.get("enabled", True)
         self._max_memories = self._config.get("max_memories_injected", 10)
         self._threshold = self._config.get("relevance_threshold", 0.3)
 
+    def _recall(self, query: str, limit: int):
+        if self._recall_fn is not None:
+            return self._recall_fn(query, limit=limit)
+        if self._engine is not None:
+            return self._engine.recall(query, limit=limit)
+        return None
+
     def get_session_context(self, project_path: str = "", query: str = "") -> str:
         """Get relevant context for a session or query.
 
         Returns a formatted string of relevant memories suitable
         for injection into an AI's system prompt.
         """
-        if not self._enabled or not self._engine:
+        if not self._enabled:
+            return ""
+        if self._recall_fn is None and self._engine is None:
             return ""
 
         try:
             # Build query from project path or explicit query
             search_query = query or f"project context {project_path}"
-            response = self._engine.recall(search_query, limit=self._max_memories)
+            response = self._recall(search_query, self._max_memories)
 
-            if not response.results:
+            if response is None or not response.results:
                 return ""
 
             # Filter by relevance threshold
@@ -56,7 +79,7 @@ class AutoRecall:
 
             return "\n".join(lines)
         except Exception as exc:
-            logger.debug("Auto-recall failed: %s", exc)
+            logger.warning("Auto-recall failed: %s", exc)
             return ""
 
     def get_query_context(self, query: str) -> list[dict]:
@@ -64,11 +87,15 @@ class AutoRecall:
 
         Returns structured data (not formatted string) for MCP tools.
         """
-        if not self._enabled or not self._engine:
+        if not self._enabled:
+            return []
+        if self._recall_fn is None and self._engine is None:
             return []
 
         try:
-            response = self._engine.recall(query, limit=self._max_memories)
+            response = self._recall(query, self._max_memories)
+            if response is None:
+                return []
             results = []
             for r in response.results:
                 if r.score >= self._threshold:
@@ -79,7 +106,7 @@ class AutoRecall:
                     })
             return results
         except Exception as exc:
-            logger.debug("Auto-recall query failed: %s", exc)
+            logger.warning("Auto-recall query failed: %s", exc)
             return []
 
     @property

package/src/superlocalmemory/mcp/_daemon_proxy.py

@@ -0,0 +1,107 @@
+# 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
+
+"""HTTP proxy that lets MCP processes use the daemon as their worker.
+
+Without this, every MCP process (one per IDE) would spawn its own
+``recall_worker`` subprocess through ``WorkerPool.shared()`` and load
+the ONNX embedder into that subprocess. With N IDEs open the total
+RSS was approximately N x 1.6 GB — the exact failure Path B was built
+to avoid.
+
+With this proxy, the MCP process opens an HTTP connection to the
+single long-lived daemon (already running for dashboard / mesh /
+health) and forwards ``recall`` and ``store`` calls there. Heavy
+engine state exists in exactly one process: the daemon.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import urllib.parse
+import urllib.request
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class DaemonPoolProxy:
+    """:class:`WorkerPool`-shaped facade that talks to the daemon over HTTP.
+
+    The shape matches ``WorkerPool.recall`` / ``WorkerPool.store`` so that
+    the existing pool adapter in ``mcp/_pool_adapter.py`` can swap between
+    a local subprocess pool and the daemon proxy without any adapter
+    change. Errors are returned as ``{"ok": False, "error": "..."}``
+    envelopes — the adapter is responsible for surfacing those.
+    """
+
+    def __init__(self, port: int, *, timeout_s: float = 30.0) -> None:
+        self._port = port
+        self._timeout = timeout_s
+
+    def _url(self, path: str) -> str:
+        return f"http://127.0.0.1:{self._port}{path}"
+
+    def recall(
+        self, query: str, limit: int = 10, session_id: str = "",
+    ) -> dict[str, Any]:
+        params = urllib.parse.urlencode(
+            {"q": query, "limit": limit, "session_id": session_id or ""}
+        )
+        try:
+            with urllib.request.urlopen(
+                self._url(f"/recall?{params}"), timeout=self._timeout,
+            ) as resp:
+                data = json.loads(resp.read().decode() or "{}")
+        except Exception as exc:
+            logger.warning("daemon /recall failed: %s", exc)
+            return {"ok": False, "error": str(exc)}
+        if not isinstance(data, dict):
+            return {"ok": False, "error": "non-dict response"}
+        data.setdefault("ok", True)
+        return data
+
+    def store(
+        self, content: str, metadata: dict | None = None,
+    ) -> dict[str, Any]:
+        body = json.dumps({
+            "content": content,
+            "tags": (metadata or {}).get("tags", ""),
+            "metadata": metadata or {},
+        }).encode()
+        req = urllib.request.Request(
+            self._url("/remember"),
+            data=body,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                data = json.loads(resp.read().decode() or "{}")
+        except Exception as exc:
+            logger.warning("daemon /remember failed: %s", exc)
+            return {"ok": False, "error": str(exc)}
+        if not isinstance(data, dict):
+            return {"ok": False, "error": "non-dict response"}
+        data.setdefault("ok", True)
+        return data
+
+
+def choose_pool() -> Any:
+    """Return the best available pool for this MCP process.
+
+    Preference order:
+      1. Running daemon — use HTTP proxy (keeps ONNX in ONE process)
+      2. No daemon — fall back to ``WorkerPool.shared()`` (spawns a
+         local subprocess with a FULL engine). This keeps single-user
+         / first-launch scenarios working.
+    """
+    try:
+        from superlocalmemory.cli.daemon import _get_port, is_daemon_running
+        if is_daemon_running():
+            return DaemonPoolProxy(port=_get_port())
+    except Exception as exc:
+        logger.warning("daemon probe failed — falling back to subprocess pool: %s", exc)
+    from superlocalmemory.core.worker_pool import WorkerPool
+    return WorkerPool.shared()

package/src/superlocalmemory/mcp/_pool_adapter.py

@@ -0,0 +1,121 @@
+# 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
+
+"""MCP-side adapters onto the pool (daemon HTTP or local subprocess).
+
+The pool returns plain dicts with an ``ok`` flag. Hooks
+(``AutoRecall`` / ``AutoCapture``) expect a ``RecallResponse``-shaped
+object and a list of fact ids. These adapters bridge the two.
+
+On ``{"ok": False, "error": "..."}`` the adapters raise
+:class:`PoolError` instead of silently returning empty results — worker
+death must be distinguishable from "no memories" on the user side.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class PoolFact:
+    fact_id: str = ""
+    content: str = ""
+    memory_id: str = ""
+
+
+@dataclass(frozen=True)
+class PoolRecallItem:
+    fact: PoolFact = field(default_factory=PoolFact)
+    score: float = 0.0
+    confidence: float = 0.0
+    trust_score: float = 0.0
+    channel_scores: dict[str, float] = field(default_factory=dict)
+    evidence_chain: list[Any] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class PoolRecallResponse:
+    results: list[PoolRecallItem] = field(default_factory=list)
+    query_type: str = ""
+    retrieval_time_ms: float = 0.0
+    channel_weights: dict[str, float] = field(default_factory=dict)
+    total_candidates: int = 0
+
+
+class PoolError(RuntimeError):
+    """Raised when the pool returns an error envelope.
+
+    Callers that want the old silent-empty behaviour (e.g. hook paths
+    that must never break the user's session) catch this and log at
+    WARNING. Callers that want to surface the failure (e.g. dashboard
+    resources) let it propagate.
+    """
+
+
+def _pool():
+    """Lazy pool factory — prefers the daemon HTTP proxy.
+
+    Split out so tests can monkey-patch the factory without touching
+    the real ``WorkerPool.shared()`` singleton.
+    """
+    from superlocalmemory.mcp._daemon_proxy import choose_pool
+    return choose_pool()
+
+
+def _unwrap_error(raw: Any, op: str) -> None:
+    """Raise PoolError if the pool returned an ``{"ok": False}`` envelope."""
+    if isinstance(raw, dict) and raw.get("ok") is False:
+        reason = raw.get("error") or "pool returned ok=False"
+        raise PoolError(f"pool.{op} failed: {reason}")
+
+
+def pool_recall(query: str, limit: int = 10, **_: Any) -> PoolRecallResponse:
+    """Call pool.recall and reshape its dict into a typed response.
+
+    Raises :class:`PoolError` on worker death or any non-ok envelope.
+    """
+    raw = _pool().recall(query=query, limit=limit)
+    _unwrap_error(raw, "recall")
+    items = raw.get("results", []) if isinstance(raw, dict) else []
+    results = [
+        PoolRecallItem(
+            fact=PoolFact(
+                fact_id=item.get("fact_id", ""),
+                content=item.get("content", ""),
+                memory_id=item.get("memory_id", ""),
+            ),
+            score=float(item.get("score", 0.0)),
+            confidence=float(item.get("confidence", 0.0)),
+            trust_score=float(item.get("trust_score", 0.0)),
+            channel_scores=item.get("channel_scores", {}) or {},
+            evidence_chain=list(item.get("evidence_chain", []) or []),
+        )
+        for item in items
+    ]
+    return PoolRecallResponse(
+        results=results,
+        query_type=raw.get("query_type", "") if isinstance(raw, dict) else "",
+        retrieval_time_ms=float(raw.get("retrieval_time_ms", 0.0))
+        if isinstance(raw, dict) else 0.0,
+        channel_weights=raw.get("channel_weights", {})
+        if isinstance(raw, dict) else {},
+        total_candidates=int(raw.get("total_candidates", 0))
+        if isinstance(raw, dict) else 0,
+    )
+
+
+def pool_store(content: str, metadata: dict | None = None) -> list[str]:
+    """Call pool.store and return the fact id list.
+
+    Raises :class:`PoolError` on worker death or any non-ok envelope.
+    """
+    raw = _pool().store(content=content, metadata=metadata or {})
+    _unwrap_error(raw, "store")
+    if isinstance(raw, dict):
+        return list(raw.get("fact_ids", []))
+    return []

package/src/superlocalmemory/mcp/resources.py

@@ -35,9 +35,9 @@ def register_resources(server, get_engine: Callable) -> None:
         """
         try:
             from superlocalmemory.hooks.auto_recall import AutoRecall
-            engine = get_engine()
+            from superlocalmemory.mcp._pool_adapter import pool_recall
             auto = AutoRecall(
-                engine=engine,
+                recall_fn=pool_recall,
                 config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
             )
             context = auto.get_session_context(query="recent decisions and important context")
@@ -200,7 +200,8 @@ def register_resources(server, get_engine: Callable) -> None:
                 from superlocalmemory.learning.behavioral import BehavioralPatternStore
                 store = BehavioralPatternStore(engine._db.db_path)
                 summary = store.get_summary(pid)
-            except Exception:
+            except Exception as exc:
+                logger.warning("learning_status behavioral summary failed: %s", exc)
                 summary = {}
 
             # Outcome stats
@@ -211,7 +212,8 @@ def register_resources(server, get_engine: Callable) -> None:
                     (pid,),
                 )
                 outcomes = {dict(r)["outcome"]: dict(r)["c"] for r in outcome_rows}
-            except Exception:
+            except Exception as exc:
+                logger.warning("learning_status outcome query failed: %s", exc)
                 outcomes = {}
 
             lines = [
@@ -245,7 +247,8 @@ def register_resources(server, get_engine: Callable) -> None:
                     (pid,),
                 )
                 activity = {dict(r)["action"]: dict(r)["c"] for r in audit_rows}
-            except Exception:
+            except Exception as exc:
+                logger.warning("engagement audit-trail query failed: %s", exc)
                 activity = {}
 
             # Top-accessed facts

package/src/superlocalmemory/mcp/server.py

@@ -31,26 +31,42 @@ server = FastMCP("SuperLocalMemory V3")
 
 # Lazy engine singleton -------------------------------------------------------
 
+import threading as _threading
 _engine = None
+_engine_lock = _threading.Lock()
 
 
 def get_engine():
-    """Return (or create) the singleton MemoryEngine."""
+    """Return (or create) the singleton LIGHT MemoryEngine.
+
+    FastMCP may call tools concurrently from multiple threads. The
+    double-checked lock keeps construction single-shot even if two
+    tool invocations race on a cold process — without it we would
+    double-run the schema migrations and build two ``AdaptiveLearner``
+    instances over the same DB file.
+    """
     global _engine
-    if _engine is None:
+    if _engine is not None:
+        return _engine
+    with _engine_lock:
+        if _engine is not None:
+            return _engine
         from superlocalmemory.core.config import SLMConfig
         from superlocalmemory.core.engine import MemoryEngine
+        from superlocalmemory.core.engine_capabilities import Capabilities
 
         config = SLMConfig.load()
-        _engine = MemoryEngine(config)
-        _engine.initialize()
+        new_engine = MemoryEngine(config, capabilities=Capabilities.LIGHT)
+        new_engine.initialize()
+        _engine = new_engine
     return _engine
 
 
 def reset_engine():
     """Reset engine singleton (for testing or mode switch)."""
     global _engine
-    _engine = None
+    with _engine_lock:
+        _engine = None
 
 
 # Register tools and resources -------------------------------------------------
@@ -71,6 +87,9 @@ _ESSENTIAL_TOOLS: set[str] = {
     "list_recent", "delete_memory", "update_memory", "get_status",
     # Session lifecycle (3)
     "session_init", "observe", "close_session",
+    # Feedback / learning signals — reachable Dash-Core path for
+    # thumbs-up / pin / drift signals.
+    "report_feedback",
     # Memory management (2)
     "forget", "run_maintenance",
     # Infinite memory + learning (4)
@@ -161,14 +180,24 @@ register_evolution_tools(_target, get_engine)  # v3.4.11: Skill evolution tools
 # the first tool call arrives (1-2s later), the engine is already warm.
 # This applies to ALL IDEs: Claude Code, Cursor, Antigravity, Gemini CLI, etc.
 def _eager_warmup() -> None:
-    """Pre-warm engine + ensure daemon is running + auto-register mesh (background thread)."""
+    """Pre-warm LIGHT engine + ensure daemon is running + auto-register mesh.
+
+    LIGHT engine init is cheap (DB only, ~100 ms). The real reason this
+    stays in a background thread is the follow-on side effects
+    (``ensure_daemon``, ``auto_register_mesh``) which do I/O.
+    """
     import logging
     _logger = logging.getLogger(__name__)
     try:
         get_engine()
         _logger.info("MCP engine pre-warmed successfully")
     except Exception as exc:
-        _logger.debug("MCP engine pre-warmup failed (non-fatal): %s", exc)
+        _logger.warning("MCP engine pre-warmup failed: %s", exc)
+
+    # Measurement / test harnesses set this to skip daemon-start and
+    # mesh-register. The LIGHT engine init above still runs.
+    if _os.environ.get("SLM_DISABLE_WARMUP_SIDE_EFFECTS") == "1":
+        return
 
     # V3.4.4: Also ensure daemon is running for dashboard/mesh/health features.
     # This runs in background — doesn't block MCP tool registration.
@@ -177,7 +206,7 @@ def _eager_warmup() -> None:
         if ensure_daemon():
             _logger.info("Daemon auto-started by MCP server")
     except Exception as exc:
-        _logger.debug("Daemon auto-start failed (non-fatal): %s", exc)
+        _logger.warning("Daemon auto-start failed: %s", exc)
 
     # V3.4.6: Auto-register this MCP session as a mesh peer immediately.
     # Previously, registration was lazy (only on first mesh tool call).
@@ -187,7 +216,7 @@ def _eager_warmup() -> None:
         auto_register_mesh()
         _logger.info("Mesh peer auto-registered at startup")
     except Exception as exc:
-        _logger.debug("Mesh auto-register failed (non-fatal): %s", exc)
+        _logger.warning("Mesh auto-register failed: %s", exc)
 
 import threading
 _warmup_thread = threading.Thread(target=_eager_warmup, daemon=True, name="mcp-warmup")

package/src/superlocalmemory/mcp/tools_active.py

@@ -28,14 +28,18 @@ DB_PATH = MEMORY_DIR / "memory.db"
 
 def _emit_event(event_type: str, payload: dict | None = None,
                 source_agent: str = "mcp_client") -> None:  # V3.3.12: see also mcp/shared.py
-    """Emit an event to the EventBus (best-effort, never raises)."""
+    """Emit an event to the EventBus (best-effort, never raises).
+
+    Dashboard visibility is load-bearing per the v3.4.26 user contract,
+    so we log on failure rather than silently dropping the signal.
+    """
     try:
         from superlocalmemory.infra.event_bus import EventBus
         bus = EventBus.get_instance(str(DB_PATH))
         bus.emit(event_type, payload=payload, source_agent=source_agent,
                  source_protocol="mcp")
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("event emit failed: type=%s err=%s", event_type, exc)
 
 
 def _register_agent(agent_id: str, profile_id: str) -> None:
@@ -45,8 +49,10 @@ def _register_agent(agent_id: str, profile_id: str) -> None:
         registry_path = MEMORY_DIR / "agents.json"
         registry = AgentRegistry(persist_path=registry_path)
         registry.register_agent(agent_id, profile_id)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning(
+            "agent registry write failed: agent=%s err=%s", agent_id, exc,
+        )
 
 
 def register_active_tools(server, get_engine: Callable) -> None:
@@ -73,6 +79,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
         try:
             from superlocalmemory.hooks.auto_recall import AutoRecall
             from superlocalmemory.hooks.rules_engine import RulesEngine
+            from superlocalmemory.mcp._pool_adapter import pool_recall
 
             engine = get_engine()
             rules = RulesEngine()
@@ -82,7 +89,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
 
             recall_config = rules.get_recall_config()
             auto = AutoRecall(
-                engine=engine,
+                recall_fn=pool_recall,
                 config={
                     "enabled": True,
                     "max_memories_injected": max_results,
@@ -102,8 +109,12 @@ def register_active_tools(server, get_engine: Callable) -> None:
             feedback_count = 0
             try:
                 feedback_count = engine._adaptive_learner.get_feedback_count(pid)
-            except Exception:
-                pass
+            except Exception as exc:
+                # Feedback count is a Dash-Core signal; a silent zero
+                # masks wiring bugs. Log so operators see the failure.
+                logger.warning(
+                    "session_init feedback_count read failed: %s", exc,
+                )
 
             # Register agent + emit event
             _register_agent("mcp_client", pid)
@@ -148,12 +159,13 @@ def register_active_tools(server, get_engine: Callable) -> None:
         try:
             from superlocalmemory.hooks.auto_capture import AutoCapture
             from superlocalmemory.hooks.rules_engine import RulesEngine
+            from superlocalmemory.mcp._pool_adapter import pool_store
 
             engine = get_engine()
             rules = RulesEngine()
 
             auto = AutoCapture(
-                engine=engine,
+                store_fn=pool_store,
                 config=rules.get_capture_config(),
             )