superlocalmemory 3.8.5 → 3.8.7

package/src/superlocalmemory/graph/cozo_backend.py

@@ -75,12 +75,12 @@ class _CozoResult:
 
 
 class _CozoClientAdapter:
-    """Bridge PyCozo 0.3 embedded bindings and later client conveniences.
+    """Bridge legacy PyCozo responses and the store-compatible client surface.
 
-    PyCozo 0.3 is the last client compatible with the published macOS native
-    binding. It returns dictionaries and exposes ``import_relations`` rather
-    than ``put``; later clients return dataframe-like values and add ``put``.
-    SLM only needs relation upserts and row results, so normalize those here.
+    SLM graph stores were established with PyCozo 0.3.0. That client returns
+    dictionaries and exposes ``import_relations`` rather than ``put``; later
+    clients return dataframe-like values and add ``put``. SLM only needs
+    relation upserts and row results, so normalize both forms here.
     """
 
     def __init__(self, client: Any) -> None:

package/src/superlocalmemory/learning/bandit.py

@@ -29,7 +29,6 @@ import os
 import secrets
 import sqlite3
 import threading
-import time
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -262,6 +261,33 @@ class ContextualBandit:
             play_id=play_id,
         )
 
+    def choose_readonly(self, context: dict[str, Any]) -> BanditChoice:
+        """Sample an arm from a read-only snapshot without recording a play.
+
+        Recall uses this method so the established bandit weighting and
+        ensemble quality path remain available without turning a query into a
+        ``bandit_plays`` write.  It deliberately bypasses the writer-oriented
+        thread-local connection factory: that factory configures WAL mode and
+        is not a physical read-only guarantee.
+        """
+        stratum = compute_stratum(context)
+        try:
+            posteriors = self._load_stratum_posteriors_readonly(stratum)
+        except sqlite3.Error as exc:
+            logger.warning(
+                "bandit.choose_readonly: posterior load failed stratum=%s: %s",
+                stratum,
+                exc,
+            )
+            posteriors = {}
+        arm_id = self._sample_best(posteriors)
+        return BanditChoice(
+            stratum=stratum,
+            arm_id=arm_id,
+            weights=dict(self._catalog[arm_id]),
+            play_id=None,
+        )
+
     def _sample_best(
         self,
         posteriors: dict[str, tuple[float, float]],
@@ -438,6 +464,29 @@ class ContextualBandit:
             for r in rows
         }
 
+    def _load_stratum_posteriors_readonly(
+        self,
+        stratum: str,
+    ) -> dict[str, tuple[float, float]]:
+        """Read posteriors through SQLite's URI read-only boundary."""
+        uri = f"{self._db_path.resolve().as_uri()}?mode=ro"
+        conn = sqlite3.connect(uri, uri=True, timeout=0.25)
+        try:
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA query_only=ON")
+            conn.execute("PRAGMA busy_timeout=250")
+            rows = conn.execute(
+                "SELECT arm_id, alpha, beta FROM bandit_arms "
+                "WHERE profile_id = ? AND stratum = ?",
+                (self._profile, stratum),
+            ).fetchall()
+        finally:
+            conn.close()
+        return {
+            row["arm_id"]: (float(row["alpha"]), float(row["beta"]))
+            for row in rows
+        }
+
     def _insert_play(
         self,
         query_id: str,

package/src/superlocalmemory/learning/source_quality.py

@@ -81,6 +81,7 @@ CREATE TABLE IF NOT EXISTS source_quality_repair_state (
 _MAX_FACTS_PER_OUTCOME = 100
 _MAX_SOURCES_PER_OUTCOME = 100
 _PROVENANCE_QUERY_CHUNK = 500
+_SCHEMA_INIT_LOCK = threading.RLock()
 
 
 class SourceQualityRepairUnavailable(RuntimeError):
@@ -114,45 +115,47 @@ class SourceQualityScorer:
     # ------------------------------------------------------------------
 
     def _ensure_schema(self) -> None:
-        conn = self._connect()
-        try:
-            # Separate scorer instances can be constructed concurrently during
-            # first startup (background history repair + outcome settlement).
-            # Serialize the read/ALTER sequence at SQLite's transaction
-            # boundary so two processes cannot both observe a legacy column as
-            # missing and race into ``duplicate column name``.
-            conn.execute("BEGIN IMMEDIATE")
-            conn.execute(_CREATE_TABLE)
-            conn.execute(_CREATE_UNIQUE)
-            conn.execute(_CREATE_OBSERVATIONS)
-            conn.execute(_CREATE_REPAIR_STATE)
-            repair_columns = {
-                str(row["name"])
-                for row in conn.execute(
-                    "PRAGMA table_info(source_quality_repair_state)"
-                ).fetchall()
-            }
-            if "last_settled_at" not in repair_columns:
-                conn.execute(
-                    "ALTER TABLE source_quality_repair_state "
-                    "ADD COLUMN last_settled_at TEXT NOT NULL DEFAULT ''"
-                )
-            if "last_outcome_id" not in repair_columns:
-                conn.execute(
-                    "ALTER TABLE source_quality_repair_state "
-                    "ADD COLUMN last_outcome_id TEXT NOT NULL DEFAULT ''"
-                )
-            conn.commit()
-        except Exception:
-            conn.rollback()
-            raise
-        finally:
-            conn.close()
+        # Serialize scorer instances in this process before asking SQLite for
+        # its cross-process BEGIN IMMEDIATE lease. This prevents two startup
+        # threads from racing the journal-mode/schema bootstrap while SQLite's
+        # busy timeout protects the equivalent multi-process boundary.
+        with _SCHEMA_INIT_LOCK:
+            conn = self._connect()
+            try:
+                conn.execute("BEGIN IMMEDIATE")
+                conn.execute(_CREATE_TABLE)
+                conn.execute(_CREATE_UNIQUE)
+                conn.execute(_CREATE_OBSERVATIONS)
+                conn.execute(_CREATE_REPAIR_STATE)
+                repair_columns = {
+                    str(row["name"])
+                    for row in conn.execute(
+                        "PRAGMA table_info(source_quality_repair_state)"
+                    ).fetchall()
+                }
+                if "last_settled_at" not in repair_columns:
+                    conn.execute(
+                        "ALTER TABLE source_quality_repair_state "
+                        "ADD COLUMN last_settled_at TEXT NOT NULL DEFAULT ''"
+                    )
+                if "last_outcome_id" not in repair_columns:
+                    conn.execute(
+                        "ALTER TABLE source_quality_repair_state "
+                        "ADD COLUMN last_outcome_id TEXT NOT NULL DEFAULT ''"
+                    )
+                conn.commit()
+            except Exception:
+                conn.rollback()
+                raise
+            finally:
+                conn.close()
 
     def _connect(self) -> sqlite3.Connection:
         conn = sqlite3.connect(str(self._db_path), timeout=10)
+        # Install the busy handler before journal negotiation. On a fresh
+        # database, PRAGMA journal_mode itself may contend with another scorer.
+        conn.execute("PRAGMA busy_timeout=10000")
         conn.execute("PRAGMA journal_mode=WAL")
-        conn.execute("PRAGMA busy_timeout=5000")
         conn.row_factory = sqlite3.Row
         return conn
 

package/src/superlocalmemory/mcp/_daemon_proxy.py

@@ -34,9 +34,26 @@ class DaemonPoolProxy:
     envelopes — the adapter is responsible for surfacing those.
     """
 
-    def __init__(self, port: int, *, timeout_s: float = 30.0) -> None:  # v3.4.59: 8s→30s — observed recall takes 13.4s on dense graph (2.1M edges); 8s always timed out → degraded mode
+    def __init__(
+        self,
+        port: int | None,
+        *,
+        timeout_s: float = 30.0,
+        unavailable: bool = False,
+    ) -> None:
+        # v3.4.59: 8s→30s — dense graph recall can exceed the old timeout.
         self._port = port
         self._timeout = timeout_s
+        self._unavailable = unavailable
+
+    @staticmethod
+    def _unavailable_response() -> dict[str, Any]:
+        return {
+            "ok": False,
+            "code": "DAEMON_UNAVAILABLE",
+            "retryable": True,
+            "error": "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+        }
 
     def recall(
         self, query: str, limit: int = 10, session_id: str = "",
@@ -45,6 +62,8 @@ class DaemonPoolProxy:
         include_shared: bool | None = None,
         window: str | None = None,
     ) -> dict[str, Any]:
+        if self._unavailable:
+            return self._unavailable_response()
         _params: dict[str, Any] = {
             "q": query,
             "limit": limit,
@@ -75,15 +94,17 @@ class DaemonPoolProxy:
             )
         except Exception as exc:
             logger.warning("daemon /recall failed: %s", exc)
-            return {"ok": False, "error": str(exc)}
+            return self._unavailable_response()
         if not isinstance(data, dict):
-            return {"ok": False, "error": "owned daemon unavailable"}
+            return self._unavailable_response()
         data.setdefault("ok", True)
         return data
 
     def store(
         self, content: str, metadata: dict | None = None,
     ) -> dict[str, Any]:
+        if self._unavailable:
+            return self._unavailable_response()
         body = {
             "content": content,
             "tags": (metadata or {}).get("tags", ""),
@@ -101,9 +122,9 @@ class DaemonPoolProxy:
             data = daemon_request("POST", "/remember", body)
         except Exception as exc:
             logger.warning("daemon /remember failed: %s", exc)
-            return {"ok": False, "error": str(exc)}
+            return self._unavailable_response()
         if not isinstance(data, dict):
-            return {"ok": False, "error": "owned daemon unavailable"}
+            return self._unavailable_response()
         data.setdefault("ok", True)
         return data
 
@@ -111,17 +132,19 @@ class DaemonPoolProxy:
 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.
+    The daemon is the sole canonical writer. A bounded daemon auto-start is
+    attempted for first use; if it cannot become healthy, return a facade that
+    reports a retryable ``DAEMON_UNAVAILABLE`` envelope. Never construct a
+    process-local ``WorkerPool`` from an MCP client.
     """
     try:
-        from superlocalmemory.cli.daemon import _get_port, is_daemon_running
-        if is_daemon_running():
+        from superlocalmemory.cli.daemon import (
+            _get_port,
+            ensure_daemon,
+            is_daemon_running,
+        )
+        if is_daemon_running() or ensure_daemon():
             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()
+        logger.warning("daemon probe or bounded start failed: %s", exc)
+    return DaemonPoolProxy(port=None, unavailable=True)

package/src/superlocalmemory/mcp/tools_active.py

@@ -19,12 +19,12 @@ from __future__ import annotations
 import asyncio
 import datetime
 import logging
-import sqlite3
 import uuid
 from typing import TYPE_CHECKING, Callable
 
-from superlocalmemory.infra.data_root import canonical_data_root, state_path
+from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.mcp.shared import authorize_mcp_mutation
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
 if TYPE_CHECKING:
     from superlocalmemory.mcp._pool_adapter import PoolRecallResponse
@@ -67,7 +67,8 @@ def _sqlite_emergency_recall(
             f"AND f.created_at >= datetime('now', '-{int(max_age_days)} days') "
             if max_age_days > 0 else ""
         )
-        conn = sqlite3.connect(str(state_path("memory.db")), timeout=5.0)
+        memory_db = state_path("memory.db").resolve()
+        conn = ReadConnectionFactory(memory_db, timeout_ms=250).open()
         try:
             rows = conn.execute(
                 f"""SELECT f.fact_id, f.content, f.memory_id, f.created_at,
@@ -139,21 +140,6 @@ def _emit_event(event_type: str, payload: dict | None = None,
         logger.warning("event emit failed: type=%s err=%s", event_type, exc)
 
 
-def _register_agent(agent_id: str, profile_id: str) -> bool:
-    """Register an agent in the AgentRegistry (best-effort)."""
-    try:
-        from superlocalmemory.core.registry import AgentRegistry
-        registry_path = canonical_data_root() / "agents.json"
-        registry = AgentRegistry(persist_path=registry_path)
-        registry.register_agent(agent_id, profile_id)
-        return True
-    except Exception as exc:
-        logger.warning(
-            "agent registry write failed: agent=%s err=%s", agent_id, exc,
-        )
-        return False
-
-
 def register_active_tools(server, get_engine: Callable) -> None:
     """Register 3 active memory tools on *server*."""
 
@@ -401,29 +387,6 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 f"-{uuid.uuid4().hex[:8]}"
             )
 
-            # Register agent + emit event (v3.4.39: SLM_AGENT_ID env support)
-            agent_id = _get_agent_id()
-            if hasattr(engine, "_hooks"):
-                registration_auth = authorize_mcp_mutation(
-                    engine,
-                    "update",
-                    mutation_source="mcp-agent-registration",
-                    profile_id=pid,
-                )
-                if _register_agent(agent_id, pid):
-                    registration_auth.complete()
-            else:
-                # A LIGHT client without the policy registry is read-capable,
-                # but must not fall back to an unauthorised registry write.
-                logger.info(
-                    "agent registration skipped: policy hooks unavailable"
-                )
-            _emit_event("agent.connected", {
-                "agent_id": agent_id,
-                "project_path": project_path,
-                "memory_count": len(memories),
-            })
-
             return {
                 "success": True,
                 "session_id": session_id,

package/src/superlocalmemory/mcp/tools_core.py

@@ -20,7 +20,7 @@ from typing import Callable
 from mcp.types import ToolAnnotations
 
 from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
-from superlocalmemory.infra.data_root import canonical_data_root, state_path
+from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.mcp.shared import authorize_mcp_mutation
 
 logger = logging.getLogger(__name__)
@@ -58,67 +58,6 @@ def _emit_event(event_type: str, payload: dict | None = None,
         pass
 
 
-def _record_recall_hits(
-    get_engine: Callable,
-    query: str,
-    results: list[dict],
-    *,
-    profile_id: str = "",
-    query_id: str = "",
-    fact_ids_candidates: list[str] | None = None,
-) -> None:
-    """Record honest shown-state signals (LLD-02 §4.9).
-
-    v3.4.22: No more fake positives. For every candidate we enqueue a
-    ``shown`` / ``not_shown`` flip based on whether it was returned in the
-    top-K presented to the user. Outcome/reward arrives in v3.4.22 via the
-    action-outcomes pipeline.
-
-    Non-blocking: all work funnels through ``signals.enqueue_shown_flip``
-    (module-level queue + background drain). Failures are swallowed —
-    signal quality is never load-bearing on recall correctness.
-    """
-    try:
-        from superlocalmemory.learning.signals import (
-            LearningSignals,
-            enqueue_shown_flip,
-        )
-
-        pid = profile_id
-        if not pid:
-            pid = get_engine().profile_id
-        slm_dir = canonical_data_root()
-
-        shown_ids = [r.get("fact_id", "") for r in results[:10]
-                     if r.get("fact_id")]
-        candidates = (fact_ids_candidates
-                      if fact_ids_candidates is not None
-                      else shown_ids)
-        if not candidates:
-            return
-
-        # Shown-flip enqueue per §4.9. No synthetic positives.
-        shown_set = set(shown_ids)
-        if query_id:
-            for fid in candidates:
-                enqueue_shown_flip(query_id, fid, shown=(fid in shown_set))
-
-        # Legacy zero-cost signals — unchanged (co-retrieval + confidence).
-        try:
-            signals = LearningSignals(slm_dir / "learning.db")
-            signals.record_co_retrieval(pid, shown_ids)
-        except Exception:
-            pass
-        try:
-            mem_db = str(slm_dir / "memory.db")
-            for fid in shown_ids[:5]:
-                LearningSignals.boost_confidence(mem_db, fid)
-        except Exception:
-            pass
-    except Exception:
-        pass
-
-
 def register_core_tools(server, get_engine: Callable) -> None:
     """Register the 13 core MCP tools on *server*."""
 
@@ -212,10 +151,10 @@ def register_core_tools(server, get_engine: Callable) -> None:
                         await _asyncio.sleep(0.05 * (attempt + 1))
                 return {
                     "success": False,
+                    "code": "DAEMON_UNAVAILABLE",
                     "retryable": True,
                     "error": (
-                        "Canonical daemon is temporarily unavailable; retry the "
-                        "same remember operation without starting a second writer."
+                        "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later."
                     ),
                 }
         except Exception as dexc:
@@ -241,11 +180,22 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 worker_meta,
             )
             if not isinstance(stored, dict) or not stored.get("ok"):
-                raise RuntimeError(
-                    (stored or {}).get("error", "canonical worker store failed")
-                    if isinstance(stored, dict)
-                    else "canonical worker returned an invalid response"
-                )
+                if isinstance(stored, dict) and stored.get("code") == "DAEMON_UNAVAILABLE":
+                    return {
+                        "success": False,
+                        "code": "DAEMON_UNAVAILABLE",
+                        "retryable": True,
+                        "error": stored.get(
+                            "error",
+                            "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+                        ),
+                    }
+                return {
+                    "success": False,
+                    "code": "DAEMON_UNAVAILABLE",
+                    "retryable": True,
+                    "error": "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+                }
             fact_ids = list(stored.get("fact_ids") or [])
             materialization_state = str(
                 stored.get("materialization_state") or "complete"
@@ -275,9 +225,14 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     else "Queryable now; canonical enrichment is still running."
                 ),
             }
-        except Exception as exc:
+        except Exception:
             logger.exception("remember failed")
-            return {"success": False, "error": str(exc)}
+            return {
+                "success": False,
+                "code": "DAEMON_UNAVAILABLE",
+                "retryable": True,
+                "error": "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+            }
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def recall(
@@ -378,22 +333,6 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 window=window or None,
             )
             if result.get("ok"):
-                # Record implicit feedback: every returned result is a recall_hit
-                try:
-                    _record_recall_hits(
-                        get_engine,
-                        query,
-                        result.get("results", []),
-                        profile_id=str(result.get("profile", "")),
-                    )
-                except Exception:
-                    pass  # Feedback is non-critical, never block recall
-                _emit_event("memory.recalled", {
-                    "query": query[:80],
-                    "result_count": result.get("result_count", 0),
-                    "query_type": result.get("query_type", "unknown"),
-                    "agent_id": agent_id,
-                }, source_agent=agent_id)
                 return {
                     "success": True,
                     "results": result.get("results", []),

package/src/superlocalmemory/mcp/tools_evolution.py

@@ -16,13 +16,11 @@ from __future__ import annotations
 
 import json
 import logging
-import sqlite3
-from datetime import datetime, timezone
-from pathlib import Path
 from typing import Callable
 
 from mcp.types import ToolAnnotations
 from superlocalmemory.infra.data_root import state_path
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
 logger = logging.getLogger(__name__)
 
@@ -146,10 +144,8 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             profile_id = engine.profile_id if engine else "default"
-            db_path = str(state_path("memory.db"))
-
-            conn = sqlite3.connect(db_path, timeout=10)
-            conn.row_factory = sqlite3.Row
+            db_path = state_path("memory.db")
+            conn = ReadConnectionFactory(db_path).open()
 
             # Gather per-skill invocation stats from tool_events
             # Skills are logged as tool_name='Skill' with actual skill name in input_summary
@@ -274,9 +270,8 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
             skill_name: Specific skill name (empty = all skills)
         """
         try:
-            db_path = str(state_path("memory.db"))
-            conn = sqlite3.connect(db_path, timeout=10)
-            conn.row_factory = sqlite3.Row
+            db_path = state_path("memory.db")
+            conn = ReadConnectionFactory(db_path).open()
 
             if skill_name:
                 rows = conn.execute(