superlocalmemory 3.8.3 → 3.8.6

package/src/superlocalmemory/core/recall_pipeline.py

@@ -14,6 +14,8 @@ from __future__ import annotations
 import hashlib
 import hmac
 import logging
+import sqlite3
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -212,6 +214,70 @@ def _behavioral_entities(results: list[Any], limit: int = 20) -> list[str]:
 _RANKING_MODES: frozenset[str] = frozenset({"off", "v1", "v2", "v2-ensemble"})
 
 
+class _ReadOnlyLearningView:
+    """Minimal learning-model reader that cannot initialise or mutate a DB."""
+
+    def __init__(self, db_path: Path) -> None:
+        self._db_path = db_path.resolve()
+
+    def _connection(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(
+            f"{self._db_path.as_uri()}?mode=ro",
+            uri=True,
+            timeout=0.25,
+        )
+        connection.row_factory = sqlite3.Row
+        connection.execute("PRAGMA query_only=ON")
+        connection.execute("PRAGMA busy_timeout=250")
+        return connection
+
+    def count_signals(self, profile_id: str) -> int:
+        connection = self._connection()
+        try:
+            row = connection.execute(
+                "SELECT COUNT(*) AS count FROM learning_signals "
+                "WHERE profile_id = ?",
+                (profile_id,),
+            ).fetchone()
+            return int(row["count"]) if row else 0
+        finally:
+            connection.close()
+
+    def count_feedback(self, profile_id: str) -> int:
+        """Count legacy feedback without running schema initialization."""
+        connection = self._connection()
+        try:
+            row = connection.execute(
+                "SELECT COUNT(*) AS count FROM learning_feedback "
+                "WHERE profile_id = ?",
+                (profile_id,),
+            ).fetchone()
+            return int(row["count"]) if row else 0
+        finally:
+            connection.close()
+
+    def load_active_model(self, profile_id: str) -> dict[str, Any] | None:
+        connection = self._connection()
+        try:
+            row = connection.execute(
+                "SELECT state_bytes, bytes_sha256, feature_names, trained_at, "
+                "model_version FROM learning_model_state "
+                "WHERE profile_id = ? AND is_active = 1 LIMIT 1",
+                (profile_id,),
+            ).fetchone()
+            if row is None:
+                return None
+            return {
+                "state_bytes": bytes(row["state_bytes"]),
+                "bytes_sha256": row["bytes_sha256"],
+                "feature_names": row["feature_names"],
+                "trained_at": row["trained_at"],
+                "model_version": row["model_version"],
+            }
+        finally:
+            connection.close()
+
+
 def _resolve_ranking_mode(env: "dict[str, str] | os._Environ[str]") -> str:
     """Map the ``SLM_RANKING`` env var to a canonical mode.
 
@@ -239,6 +305,7 @@ def apply_ranking(
     *,
     config: Any = None,
     pipeline_version: str = "v2-ensemble",
+    record_signals: bool = False,
 ) -> "RecallResponse":
     """Run the ranking pipeline at the requested version.
 
@@ -273,6 +340,7 @@ def apply_ranking(
     try:
         response = apply_v2_bandit_ensemble(
             response, query, profile_id, query_id,
+            record_signals=record_signals,
         )
     except Exception as exc:  # pragma: no cover — defensive
         logger.debug("apply_ranking ensemble step skipped: %s", exc)
@@ -297,14 +365,16 @@ def apply_adaptive_ranking(
     Phase 3 (200+): LightGBM ML-based reranking.
     """
     from superlocalmemory.infra.data_root import state_path
-    from superlocalmemory.learning.feedback import FeedbackCollector
-
     learning_db = state_path("learning.db")
     if not learning_db.exists():
         return response
 
-    collector = FeedbackCollector(learning_db)
-    signal_count = collector.get_feedback_count(pid)
+    try:
+        signal_count = _ReadOnlyLearningView(learning_db).count_feedback(pid)
+    except sqlite3.Error:
+        # A pre-learning database may not have this optional table yet.
+        # Recall remains a query and cannot create it on demand.
+        return response
 
     if signal_count < 50:
         return response  # Phase 1: no change
@@ -388,7 +458,6 @@ def apply_v2_adaptive_ranking(
         from pathlib import Path as _P
 
         from superlocalmemory.infra.data_root import state_path
-        from superlocalmemory.learning.database import LearningDatabase
         from superlocalmemory.learning.model_cache import load_active
         from superlocalmemory.learning.ranker import AdaptiveRanker
 
@@ -397,7 +466,7 @@ def apply_v2_adaptive_ranking(
         if not db_path.exists():
             return response
 
-        db = LearningDatabase(db_path)
+        db = _ReadOnlyLearningView(db_path)
         signal_count = db.count_signals(profile_id)
         active = load_active(db, profile_id)
 
@@ -487,6 +556,7 @@ def apply_v2_bandit_ensemble(
     query_id: str,
     *,
     learning_db_path: Any = None,
+    record_signals: bool = False,
 ) -> RecallResponse:
     """Apply contextual bandit + optional LGBM ensemble rerank. Safe on error."""
     import os as _os
@@ -521,12 +591,14 @@ def apply_v2_bandit_ensemble(
         entity_count = 0
         # Use query_context hints if available on the engine — cheap fallback.
         bandit = ContextualBandit(db_path, profile_id)
-        choice = bandit.choose(
-            {
-                "query_type": response.query_type,
-                "entity_count": entity_count,
-            },
-            query_id,
+        context = {
+            "query_type": response.query_type,
+            "entity_count": entity_count,
+        }
+        choice = (
+            bandit.choose(context, query_id)
+            if record_signals
+            else bandit.choose_readonly(context)
         )
 
         # --- 2. apply channel weights -------------------------------------
@@ -536,9 +608,8 @@ def apply_v2_bandit_ensemble(
         active_model = None
         signal_count = 0
         try:
-            from superlocalmemory.learning.database import LearningDatabase
             from superlocalmemory.learning.model_cache import load_active
-            db = LearningDatabase(db_path)
+            db = _ReadOnlyLearningView(db_path)
             signal_count = db.count_signals(profile_id)
             active_model = load_active(db, profile_id)
         except Exception as exc:
@@ -561,28 +632,32 @@ def apply_v2_bandit_ensemble(
             logger.debug("v2 bandit ensemble_rerank skipped: %s", exc)
             final_results = weighted
 
-        # --- 5. enqueue signals (non-blocking) ----------------------------
-        try:
-            top20 = final_results[:20]
-            candidates = tuple(
-                SignalCandidate(
-                    fact_id=r.fact.fact_id,
-                    channel_scores=dict(r.channel_scores or {}),
-                    cross_encoder_score=None,
-                    result_dict={"fact_id": r.fact.fact_id,
-                                 "score": r.score},
+        # Recall is a query.  Implicit learning signals are deliberately
+        # disabled on this path: even a non-blocking enqueue eventually writes
+        # canonical/learning state and turns dashboard polling into contention.
+        # An explicit feedback command owns durable learning signals instead.
+        if record_signals:
+            try:
+                top20 = final_results[:20]
+                candidates = tuple(
+                    SignalCandidate(
+                        fact_id=r.fact.fact_id,
+                        channel_scores=dict(r.channel_scores or {}),
+                        cross_encoder_score=None,
+                        result_dict={"fact_id": r.fact.fact_id,
+                                     "score": r.score},
+                    )
+                    for r in top20
                 )
-                for r in top20
-            )
-            enqueue(SignalBatch(
-                profile_id=profile_id,
-                query_id=query_id,
-                query_text=query,
-                candidates=candidates,
-                query_context=query_context,
-            ))
-        except Exception as exc:
-            logger.debug("v2 bandit signal enqueue skipped: %s", exc)
+                enqueue(SignalBatch(
+                    profile_id=profile_id,
+                    query_id=query_id,
+                    query_text=query,
+                    candidates=candidates,
+                    query_context=query_context,
+                ))
+            except Exception as exc:
+                logger.debug("v2 bandit signal enqueue skipped: %s", exc)
 
         return RecallResponse(
             query=response.query,
@@ -665,15 +740,6 @@ def run_recall(
     agent hot path skips the internal round and delegates refinement to the
     calling LLM. ``fast=False`` forces the internal agentic round.
     """
-    # Pre-operation hooks
-    hook_ctx = {
-        "operation": "recall",
-        "agent_id": agent_id,
-        "profile_id": profile_id,
-        "query_preview": query[:100],
-    }
-    hooks.run_pre("recall", hook_ctx)
-
     m = mode or config.mode
 
     # v3.8.2: resolve the client-driven-agentic default when a caller left
@@ -772,30 +838,6 @@ def run_recall(
                 logger.debug("Agentic sufficiency skipped: %s", exc)
 
     _mark("agentic")
-    # V3.2: Log access for recalled facts (Phase 1)
-    if access_log and response.results:
-        try:
-            fact_ids = [r.fact.fact_id for r in response.results]
-            access_log.store_access_batch(
-                fact_ids=fact_ids,
-                profile_id=profile_id,
-                access_type="recall",
-            )
-        except Exception as exc:
-            logger.debug("Access log batch store failed: %s", exc)
-
-    # Query telemetry is permitted, but result-derived entities are not fed
-    # back as preferences.  Retrieval exposure is not positive feedback.
-    try:
-        _get_behavioral_tracker(db).record_query(
-            query=query,
-            query_type=response.query_type,
-            entities=[],
-            profile_id=profile_id,
-        )
-    except Exception as exc:
-        logger.debug("Behavioral tracking: %s", exc)
-
     # S8-ARC-04 (v3.4.22): unified ranking entry point. Single env-var
     # (SLM_RANKING=off|v1|v2|v2-ensemble) controls the pipeline. Legacy
     # SLM_V2_PIPELINE_DISABLED + SLM_BANDIT_DISABLED still honoured for
@@ -807,7 +849,7 @@ def run_recall(
         mode = _resolve_ranking_mode(_os.environ)
         response = apply_ranking(
             response, query, profile_id, query_id,
-            config=config, pipeline_version=mode,
+            config=config, pipeline_version=mode, record_signals=False,
         )
     except Exception as exc:
         logger.debug("Ranking pipeline skipped: %s", exc)
@@ -817,11 +859,6 @@ def run_recall(
     # mutation here.  Those state transitions require a separately authenticated
     # positive/negative outcome; merely returning a result is an exposure.
 
-    # Post-operation hooks (audit, trust signal, learning)
-    hook_ctx["result_count"] = len(response.results)
-    hook_ctx["query_type"] = response.query_type
-    hooks.run_post("recall", hook_ctx)
-
     from superlocalmemory.core.score_contract import finalize_score_contract
     finalize_score_contract(response)
 

package/src/superlocalmemory/core/registry.py

@@ -110,7 +110,11 @@ class AgentRegistry:
         try:
             data = json.loads(self._path.read_text(encoding="utf-8"))
             self._agents = data.get("agents", {})
-            self._write_locks = data.get("write_locks", {})
+            # D-01: write_locks from a prior process are meaningless after a
+            # process boundary — the agents that held them are dead.  Starting
+            # with no inherited locks prevents mcp_client (and any other agent)
+            # from being permanently blocked on every daemon restart.
+            self._write_locks = {}
         except (json.JSONDecodeError, KeyError):
             logger.warning("Corrupt registry file at %s — starting fresh.", self._path)
             self._agents = {}

package/src/superlocalmemory/core/remember_admission.py

@@ -0,0 +1,152 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""Journal-first service boundary for a durable, immediately-queryable remember."""
+
+from __future__ import annotations
+
+import math
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from superlocalmemory.storage.admission_journal import (
+    Actor,
+    AdmissionJournal,
+    AdmissionJournalUnavailable,
+    PreparedAdmission,
+    RememberRequest,
+    TerminalAdmissionError,
+)
+
+
+class AdmissionRejected(RuntimeError):
+    """Canonical admission was not committed; the journal records its outcome."""
+
+    def __init__(self, error_code: str, *, retryable: bool = False) -> None:
+        super().__init__(error_code)
+        self.error_code = error_code
+        self.retryable = retryable
+
+
+@dataclass(frozen=True, slots=True)
+class RememberReceipt:
+    """Canonical receipt returned only after admission is queryable."""
+
+    payload: dict[str, Any]
+
+    @classmethod
+    def from_mapping(cls, receipt: Mapping[str, Any]) -> RememberReceipt:
+        return cls(payload=dict(receipt))
+
+
+@dataclass(frozen=True, slots=True)
+class RememberAdmissionCommand:
+    """Typed foreground input for a coordinator's bounded canonical transaction."""
+
+    journal_id: str
+    request_hash: str
+    request: RememberRequest
+    profile_id: str
+    idempotency_key: str
+
+    @classmethod
+    def from_prepared(
+        cls, prepared: PreparedAdmission, request: RememberRequest
+    ) -> RememberAdmissionCommand:
+        return cls(
+            journal_id=prepared.journal_id,
+            request_hash=prepared.request_hash,
+            request=request,
+            profile_id=prepared.profile_id,
+            idempotency_key=prepared.idempotency_key,
+        )
+
+
+class RememberCoordinator(Protocol):
+    def submit(self, command: RememberAdmissionCommand, *, wait_ms: int) -> Any: ...
+
+
+class RememberService:
+    """Apply the journaling pattern without doing enrichment inside admission."""
+
+    def __init__(self, journal: AdmissionJournal, coordinator: RememberCoordinator) -> None:
+        self._journal = journal
+        self._coordinator = coordinator
+
+    def remember(
+        self, request: RememberRequest, actor: Actor, *, deadline_ms: int
+    ) -> RememberReceipt:
+        if deadline_ms <= 0:
+            raise ValueError("deadline_ms must be greater than zero")
+        deadline = time.monotonic() + deadline_ms / 1_000
+        prepared = self._journal.prepare(
+            request,
+            actor,
+            deadline=deadline,
+        )
+        if prepared.original_receipt is not None:
+            return RememberReceipt.from_mapping(prepared.original_receipt)
+        if prepared.state == "rejected":
+            raise AdmissionRejected(prepared.error_code or "COMMAND_REJECTED")
+
+        command_request = self._journal.request_for(
+            prepared,
+            deadline=deadline,
+        )
+        dispatched = self._journal.mark_dispatched(
+            prepared.journal_id,
+            deadline=deadline,
+        )
+        if dispatched.original_receipt is not None:
+            return RememberReceipt.from_mapping(dispatched.original_receipt)
+        try:
+            result = self._coordinator.submit(
+                RememberAdmissionCommand.from_prepared(prepared, command_request),
+                wait_ms=_remaining_milliseconds(deadline),
+            )
+        except TerminalAdmissionError as exc:
+            self._journal.mark_rejected(
+                prepared.journal_id,
+                exc.error_code,
+                deadline=deadline,
+            )
+            raise AdmissionRejected(exc.error_code) from exc
+        state = _result_value(result, "state")
+        receipt = _result_value(result, "receipt") or {}
+        if state in {"committed", "duplicate"}:
+            if not isinstance(receipt, Mapping):
+                raise AdmissionRejected("COMMAND_REJECTED: canonical result had no receipt")
+            committed = self._journal.mark_committed(
+                prepared.journal_id,
+                receipt,
+                deadline=deadline,
+            )
+            return RememberReceipt.from_mapping(committed.original_receipt or receipt)
+
+        error_code = str(_result_value(result, "error_code") or "COMMAND_REJECTED")
+        if state == "rejected":
+            self._journal.mark_rejected(
+                prepared.journal_id,
+                error_code,
+                deadline=deadline,
+            )
+        raise AdmissionRejected(error_code, retryable=state != "rejected")
+
+
+def _result_value(result: Any, key: str) -> Any:
+    if isinstance(result, Mapping):
+        return result.get(key)
+    return getattr(result, key, None)
+
+
+def _remaining_seconds(deadline: float) -> float:
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        raise AdmissionJournalUnavailable("remember admission deadline expired")
+    return remaining
+
+
+def _remaining_milliseconds(deadline: float) -> int:
+    return max(1, math.ceil(_remaining_seconds(deadline) * 1_000))