superlocalmemory 3.4.45 → 3.4.46

package/CHANGELOG.md

@@ -9,6 +9,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [3.4.46] - 2026-05-18
+
+### Added
+- **`SLM_MCP_TOOLS` env var** — Fine-grained MCP tool allowlist. Users can now
+  set `SLM_MCP_TOOLS=remember,recall,search,session_init` to expose exactly
+  the tools they need, reducing MCP context budget. Falls back to 25-tool
+  essential set when unset; `SLM_MCP_ALL_TOOLS=1` still wins for power users.
+- **`KMP_DUPLICATE_LIB_OK=TRUE`** — Set at package init to prevent OpenMP
+  multi-library crashes when PyTorch, ONNX Runtime, and NumPy-MKL all load
+  their own runtimes simultaneously.
+
+### Fixed
+- **WAL busy_timeout ordering** (PR #24, @kenyonxu) — `_enable_wal()` now
+  sets `busy_timeout` before `journal_mode=WAL`, ensuring the 10s configured
+  timeout is used instead of SQLite's default 5s during WAL initialization.
+- **Engine init traceback logging** (PR #25, @kenyonxu) — `logger.exception()`
+  replaces `logger.warning()` on daemon engine init failure, capturing the
+  full traceback for root-cause diagnosis.
+- **MCP `fast` recall wiring** (PR #22, @VikingOwl91) — `fast=True` recall
+  parameter now threads through the full MCP→daemon→worker stack.
+  `session_init` performs one `pool_recall(fast=True)` instead of two
+  redundant recalls. Tools switch from `WorkerPool.shared()` to `choose_pool()`
+  for daemon-first routing (avoids N×1.6 GB ONNX duplication across IDEs).
+- **FTS trigger idempotency** — `CREATE TRIGGER IF NOT EXISTS` prevents race
+  crashes on repeated schema init.
+
+---
+
 ## [3.4.43] - 2026-05-12
 
 Smart-hook architecture release. Replaces the time-based 15-minute recall

package/package.json

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

package/src/superlocalmemory/__init__.py

@@ -1,6 +1,9 @@
 """SuperLocalMemory — information-geometric agent memory."""
 
-__version__ = "3.4.45"
+import os
+os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
+
+__version__ = "3.4.46"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/core/recall_worker.py

@@ -59,10 +59,12 @@ def _get_engine():
     return _engine
 
 
-def _handle_recall(query: str, limit: int, session_id: str = "") -> dict:
+def _handle_recall(
+    query: str, limit: int, session_id: str = "", fast: bool = False,
+) -> dict:
     engine = _get_engine()
     response = engine.recall(
-        query, limit=limit, session_id=session_id or None,
+        query, limit=limit, session_id=session_id or None, fast=bool(fast),
     )
 
     # Batch-fetch original memory text for all results
@@ -290,7 +292,7 @@ def _worker_main() -> None:
             if cmd == "recall":
                 result = _handle_recall(
                     req.get("query", ""), req.get("limit", 10),
-                    req.get("session_id", ""),
+                    req.get("session_id", ""), bool(req.get("fast", False)),
                 )
                 _respond(result)
             elif cmd == "store":

package/src/superlocalmemory/core/worker_pool.py

@@ -67,6 +67,7 @@ class WorkerPool:
 
     def recall(
         self, query: str, limit: int = 10, session_id: str = "",
+        fast: bool = False,
     ) -> dict:
         """Run recall in worker subprocess. Returns result dict.
 
@@ -77,7 +78,7 @@ class WorkerPool:
         """
         return self._send({
             "cmd": "recall", "query": query, "limit": limit,
-            "session_id": session_id or "",
+            "session_id": session_id or "", "fast": bool(fast),
         })
 
     def store(self, content: str, metadata: dict | None = None) -> dict:

package/src/superlocalmemory/mcp/_daemon_proxy.py

@@ -45,10 +45,14 @@ class DaemonPoolProxy:
 
     def recall(
         self, query: str, limit: int = 10, session_id: str = "",
+        fast: bool = False,
     ) -> dict[str, Any]:
-        params = urllib.parse.urlencode(
-            {"q": query, "limit": limit, "session_id": session_id or ""}
-        )
+        params = urllib.parse.urlencode({
+            "q": query,
+            "limit": limit,
+            "session_id": session_id or "",
+            "fast": "true" if fast else "false",
+        })
         try:
             with urllib.request.urlopen(
                 self._url(f"/recall?{params}"), timeout=self._timeout,

package/src/superlocalmemory/mcp/_pool_adapter.py

@@ -74,12 +74,17 @@ def _unwrap_error(raw: Any, op: str) -> None:
         raise PoolError(f"pool.{op} failed: {reason}")
 
 
-def pool_recall(query: str, limit: int = 10, **_: Any) -> PoolRecallResponse:
+def pool_recall(query: str, limit: int = 10, **kwargs: 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)
+    raw = _pool().recall(
+        query=query,
+        limit=limit,
+        session_id=str(kwargs.get("session_id") or ""),
+        fast=bool(kwargs.get("fast", False)),
+    )
     _unwrap_error(raw, "recall")
     items = raw.get("results", []) if isinstance(raw, dict) else []
     results = [

package/src/superlocalmemory/mcp/server.py

@@ -122,13 +122,21 @@ _ESSENTIAL_TOOLS = frozenset(_ESSENTIAL_TOOLS)
 
 _all_tools = _os_reg.environ.get("SLM_MCP_ALL_TOOLS") == "1"
 
+# v3.4.45: Minimal mode — explicit user allowlist via SLM_MCP_TOOLS env var.
+# Format: comma-separated tool names, e.g. "remember,recall,session_init,search"
+# Use case: Claude Code consumer plans with tight context budgets where the
+# 25-tool essential set is still too many. Power users override to expose
+# exactly the tools they invoke. Falls back to _ESSENTIAL_TOOLS when unset.
+_user_allowlist_str = _os_reg.environ.get("SLM_MCP_TOOLS", "").strip()
+
 
 class _FilteredServer:
     """Wraps FastMCP to only register essential tools.
 
     Non-essential tools are silently skipped (not registered on the MCP
     server). They remain available via CLI. When SLM_MCP_ALL_TOOLS=1,
-    all tools are registered (bypass filter).
+    all tools are registered (bypass filter). When SLM_MCP_TOOLS is set,
+    that user allowlist is used instead of _ESSENTIAL_TOOLS.
     """
     __slots__ = ("_server", "_allowed")
 
@@ -147,8 +155,14 @@ class _FilteredServer:
         return getattr(self._server, name)
 
 
-# Choose full or filtered registration target
-_target = server if _all_tools else _FilteredServer(server, _ESSENTIAL_TOOLS)
+# Choose registration target (precedence: ALL > user allowlist > essential)
+if _all_tools:
+    _target = server
+elif _user_allowlist_str:
+    _user_allowlist = frozenset(t.strip() for t in _user_allowlist_str.split(",") if t.strip())
+    _target = _FilteredServer(server, _user_allowlist)
+else:
+    _target = _FilteredServer(server, _ESSENTIAL_TOOLS)
 
 from superlocalmemory.mcp.tools_core import register_core_tools
 from superlocalmemory.mcp.tools_v28 import register_v28_tools

package/src/superlocalmemory/mcp/tools_active.py

@@ -93,7 +93,6 @@ def register_active_tools(server, get_engine: Callable) -> None:
         The AI should call this automatically before any other work.
         """
         try:
-            from superlocalmemory.hooks.auto_recall import AutoRecall
             from superlocalmemory.hooks.rules_engine import RulesEngine
             from superlocalmemory.mcp._pool_adapter import pool_recall
 
@@ -104,21 +103,37 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 return {"success": True, "context": "", "memories": [], "message": "Auto-recall disabled"}
 
             recall_config = rules.get_recall_config()
-            auto = AutoRecall(
-                recall_fn=pool_recall,
-                config={
-                    "enabled": True,
-                    "max_memories_injected": max_results,
-                    "relevance_threshold": recall_config.get("relevance_threshold", 0.3),
-                },
-            )
-
-            # Get formatted context for system prompt injection
-            context = auto.get_session_context(project_path=project_path, query=query)
-
-            # Get structured results for tool response
-            search_query = query or f"project context {project_path}" if project_path else "recent important decisions"
-            memories = auto.get_query_context(search_query)
+            relevance_threshold = recall_config.get("relevance_threshold", 0.3)
+            if query:
+                search_query = query
+            elif project_path:
+                search_query = f"project context {project_path}"
+            else:
+                search_query = "recent important decisions"
+
+            response = pool_recall(search_query, limit=max_results, fast=True)
+            relevant = [
+                r for r in response.results
+                if r.score >= relevance_threshold
+            ]
+
+            # Build both return shapes from one recall. Calling recall twice
+            # doubles session startup latency and can return duplicate snippets.
+            context = ""
+            if relevant:
+                lines = ["# Relevant Memory Context", ""]
+                for r in relevant[:max_results]:
+                    lines.append(f"- {r.fact.content[:200]}")
+                context = "\n".join(lines)
+
+            memories = [
+                {
+                    "fact_id": r.fact.fact_id,
+                    "content": r.fact.content[:300],
+                    "score": round(r.score, 3),
+                }
+                for r in relevant[:max_results]
+            ]
 
             # Get learning status
             pid = engine.profile_id
@@ -184,7 +199,6 @@ def register_active_tools(server, get_engine: Callable) -> None:
             from superlocalmemory.hooks.rules_engine import RulesEngine
             from superlocalmemory.mcp._pool_adapter import pool_store
 
-            engine = get_engine()
             rules = RulesEngine()
 
             auto = AutoCapture(
@@ -305,7 +319,6 @@ def register_active_tools(server, get_engine: Callable) -> None:
         """
         try:
             engine = get_engine()
-            pid = engine.profile_id
             sid = session_id or getattr(engine, '_last_session_id', '')
             if not sid:
                 return {"success": False, "error": "No session_id provided"}

package/src/superlocalmemory/mcp/tools_core.py

@@ -13,10 +13,9 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
-import json
 import logging
 from pathlib import Path
-from typing import Any, Callable
+from typing import Callable
 
 from mcp.types import ToolAnnotations
 
@@ -111,7 +110,6 @@ def register_core_tools(server, get_engine: Callable) -> None:
         Extracts atomic facts, resolves entities, builds graph edges,
         and indexes for 4-channel retrieval.
         """
-        import asyncio
         try:
             # v3.4.32: Store-first pattern. Write to pending.db and return
             # immediately. The daemon's pending-materializer thread drains
@@ -141,7 +139,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def recall(
         query: str, limit: int = 10, agent_id: str = "mcp_client",
-        session_id: str = "",
+        session_id: str = "", fast: bool = False,
     ) -> dict:
         """Search memories by semantic query with 4-channel retrieval, RRF fusion, and reranking.
 
@@ -153,8 +151,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
         """
         import asyncio
         try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            pool = WorkerPool.shared()
+            from superlocalmemory.mcp._daemon_proxy import choose_pool
+            pool = choose_pool()
             # S9-DASH-10: priority for session_id, so engagement
             # signals land on the right pending_outcome:
             #   1. Explicit ``session_id`` tool-call argument.
@@ -199,6 +197,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             # block behind a single threading.Lock. See worker_pool.py.
             result = await asyncio.to_thread(
                 pool.recall, query, limit=limit, session_id=effective_sid,
+                fast=bool(fast),
             )
             if result.get("ok"):
                 # Record implicit feedback: every returned result is a recall_hit

package/src/superlocalmemory/mcp/tools_v3.py

@@ -285,8 +285,8 @@ def register_v3_tools(server, get_engine: Callable) -> None:
             limit: Maximum results (default 10).
         """
         try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            raw = WorkerPool.shared().recall(query=query, limit=limit)
+            from superlocalmemory.mcp._daemon_proxy import choose_pool
+            raw = choose_pool().recall(query=query, limit=limit)
             items = raw.get("results", []) if isinstance(raw, dict) else []
             results = []
             for item in items[:limit]:

package/src/superlocalmemory/server/unified_daemon.py

@@ -535,8 +535,8 @@ async def lifespan(application: FastAPI):
             application.state.queue_consumer = None
             application.state.recall_queue = None
 
-    except Exception as exc:
-        logger.warning("Engine init failed: %s", exc)
+    except Exception:
+        logger.exception("Engine init failed")  # auto-includes traceback
         application.state.engine = None
         application.state.config = None
 

package/src/superlocalmemory/storage/database.py

@@ -66,8 +66,8 @@ class DatabaseManager:
     def _enable_wal(self) -> None:
         conn = sqlite3.connect(str(self.db_path))
         try:
+            conn.execute(f"PRAGMA busy_timeout={_BUSY_TIMEOUT_MS}")  # FIRST — so WAL pragma below uses configured timeout
             conn.execute("PRAGMA journal_mode=WAL")
-            conn.execute(f"PRAGMA busy_timeout={_BUSY_TIMEOUT_MS}")
             conn.execute("PRAGMA foreign_keys=ON")
             conn.commit()
         finally:

package/src/superlocalmemory/storage/schema.py

@@ -252,7 +252,7 @@ CREATE VIRTUAL TABLE IF NOT EXISTS atomic_facts_fts
 -- left by V2 migration.
 
 -- INSERT trigger
-CREATE TRIGGER atomic_facts_fts_insert
+CREATE TRIGGER IF NOT EXISTS atomic_facts_fts_insert
     AFTER INSERT ON atomic_facts
 BEGIN
     INSERT INTO atomic_facts_fts (rowid, fact_id, content)
@@ -260,7 +260,7 @@ BEGIN
 END;
 
 -- DELETE trigger
-CREATE TRIGGER atomic_facts_fts_delete
+CREATE TRIGGER IF NOT EXISTS atomic_facts_fts_delete
     AFTER DELETE ON atomic_facts
 BEGIN
     INSERT INTO atomic_facts_fts (atomic_facts_fts, rowid, fact_id, content)
@@ -268,7 +268,7 @@ BEGIN
 END;
 
 -- UPDATE trigger
-CREATE TRIGGER atomic_facts_fts_update
+CREATE TRIGGER IF NOT EXISTS atomic_facts_fts_update
     AFTER UPDATE OF content ON atomic_facts
 BEGIN
     INSERT INTO atomic_facts_fts (atomic_facts_fts, rowid, fact_id, content)