superlocalmemory 3.8.3 → 3.8.6

package/src/superlocalmemory/retrieval/reranker.py

@@ -68,6 +68,21 @@ _SUBPROCESS_RESPONSE_TIMEOUT = 15  # v3.4.52: 15s (was 180s). Long timeout block
 # scores without reranking.
 _WORKER_RECYCLE_AFTER = 500  # Recycle after N requests
 
+# One-time model load is far heavier than a live rerank request: the child
+# process imports torch / sentence-transformers and runs a warmup inference,
+# which measured 9-16s on the reference machine.  Sharing the 15s live-request
+# timeout (``_SUBPROCESS_RESPONSE_TIMEOUT``) made the load a coin flip — logs
+# showed ~half of daemon boots hitting "timed out after 15s", killing the
+# worker, and leaving recall on FALLBACK scoring for the entire daemon
+# lifetime (a silent quality regression, not a transient one).  The load gets
+# its own generous budget, and the background warmup RETRIES with backoff so a
+# transient slow/failed load self-heals instead of permanently degrading
+# recall quality.  Live rerank requests keep the tight 15s cap so a recall
+# never blocks on a sick subprocess.
+_WARMUP_LOAD_TIMEOUT = int(os.environ.get("SLM_RERANKER_WARMUP_TIMEOUT", "90"))
+_WARMUP_MAX_ATTEMPTS = int(os.environ.get("SLM_RERANKER_WARMUP_ATTEMPTS", "5"))
+_WARMUP_RETRY_BACKOFF_S = float(os.environ.get("SLM_RERANKER_WARMUP_BACKOFF", "3"))
+
 
 class CrossEncoderReranker:
     """Rerank candidate facts using a local cross-encoder model.
@@ -96,6 +111,8 @@ class CrossEncoderReranker:
         self._model_loaded = False  # True once worker confirms model is ready
         self._worker_loading = False  # True while background warmup in progress
         self._lock = threading.Lock()
+        self._shutdown_event = threading.Event()
+        self._warmup_thread: threading.Thread | None = None
         self._idle_timer: threading.Timer | None = None
         self._request_count: int = 0
 
@@ -111,7 +128,7 @@ class CrossEncoderReranker:
     def __del__(self) -> None:
         """Kill worker subprocess when reranker is garbage-collected."""
         try:
-            self._kill_worker()
+            self.shutdown(timeout=0.1)
         except Exception:
             pass
 
@@ -127,26 +144,81 @@ class CrossEncoderReranker:
         lock, creating a race where the warmup's readline thread could
         steal responses meant for _send_request → deadlock → timeout.
         """
-        if self._worker_loading or self._model_loaded:
+        if self._shutdown_event.is_set() or self._worker_loading or self._model_loaded:
             return
         self._worker_loading = True
 
         def _warmup() -> None:
             try:
-                self._ensure_worker()
-                if self._worker_proc is None:
-                    return
-                resp = self._send_request({
-                    "cmd": "load",
-                    "model_name": self._model_name,
-                    "backend": self._backend,
-                }, timeout=_SUBPROCESS_RESPONSE_TIMEOUT)
-                if resp and resp.get("ok"):
-                    self._model_loaded = True
-                    logger.info(
-                        "Reranker worker warm (backend=%s, warmup_inference=%s)",
-                        resp.get("backend", "?"),
-                        resp.get("warmup_inference", False),
+                for attempt in range(1, _WARMUP_MAX_ATTEMPTS + 1):
+                    if self._shutdown_event.is_set() or self._model_loaded:
+                        return
+                    try:
+                        self._ensure_worker()
+                    except Exception as exc:
+                        logger.warning(
+                            "Reranker warmup attempt %d/%d: worker spawn "
+                            "raised: %s", attempt, _WARMUP_MAX_ATTEMPTS, exc,
+                        )
+                        self._worker_proc = None
+
+                    if self._worker_proc is None:
+                        # Either the spawn failed, or another process already
+                        # owns the machine-wide singleton worker.  If a sibling
+                        # worker is alive this instance will use it on demand —
+                        # stop retrying quietly rather than spinning.
+                        if _is_reranker_worker_alive():
+                            logger.debug(
+                                "Reranker warmup: worker owned by another "
+                                "process; this instance uses it on demand",
+                            )
+                            return
+                    else:
+                        # Give the ONE-TIME model load a generous budget — it is
+                        # far heavier than a live rerank request. On timeout
+                        # _send_request kills the worker, so the next attempt
+                        # respawns cleanly (no stale-response race).
+                        resp = None
+                        try:
+                            resp = self._send_request({
+                                "cmd": "load",
+                                "model_name": self._model_name,
+                                "backend": self._backend,
+                            }, timeout=_WARMUP_LOAD_TIMEOUT)
+                        except Exception as exc:
+                            logger.warning(
+                                "Reranker warmup attempt %d/%d: load request "
+                                "raised: %s",
+                                attempt, _WARMUP_MAX_ATTEMPTS, exc,
+                            )
+                        if resp and resp.get("ok"):
+                            self._model_loaded = True
+                            logger.info(
+                                "Reranker worker warm (attempt %d/%d, "
+                                "backend=%s, warmup_inference=%s)",
+                                attempt, _WARMUP_MAX_ATTEMPTS,
+                                resp.get("backend", "?"),
+                                resp.get("warmup_inference", False),
+                            )
+                            return
+                        logger.warning(
+                            "Reranker warmup attempt %d/%d did not confirm "
+                            "ready (timeout=%ds); retrying",
+                            attempt, _WARMUP_MAX_ATTEMPTS, _WARMUP_LOAD_TIMEOUT,
+                        )
+
+                    if attempt < _WARMUP_MAX_ATTEMPTS and not self._model_loaded:
+                        if self._shutdown_event.wait(
+                            min(_WARMUP_RETRY_BACKOFF_S * attempt, 15.0),
+                        ):
+                            return
+
+                if not self._model_loaded:
+                    logger.warning(
+                        "Reranker warmup exhausted %d attempts; recall uses "
+                        "fallback scoring until the next rerank triggers a "
+                        "fresh load. Run 'slm doctor' for diagnostics.",
+                        _WARMUP_MAX_ATTEMPTS,
                     )
             except Exception as exc:
                 logger.debug("Background reranker warmup failed: %s", exc)
@@ -164,7 +236,11 @@ class CrossEncoderReranker:
         """
         if self._model_loaded:
             return True
-        if not self._worker_loading and not self._model_loaded:
+        if (
+            not self._shutdown_event.is_set()
+            and not self._worker_loading
+            and not self._model_loaded
+        ):
             self._start_background_warmup()
         t = getattr(self, '_warmup_thread', None)
         if t is not None:
@@ -181,6 +257,8 @@ class CrossEncoderReranker:
         v3.4.13: Checks PID file before spawning — only ONE reranker worker
         can exist at a time on the machine.
         """
+        if self._shutdown_event.is_set():
+            return
         if self._worker_proc is not None and self._worker_proc.poll() is None:
             return
         self._worker_proc = None
@@ -260,6 +338,8 @@ class CrossEncoderReranker:
         falls back to fusion scores without reranking). This prevents
         concurrent recall requests from serialising on the lock.
         """
+        if self._shutdown_event.is_set():
+            return None
         effective_timeout = timeout or _SUBPROCESS_RESPONSE_TIMEOUT
 
         acquired = self._lock.acquire(blocking=block)
@@ -326,7 +406,7 @@ class CrossEncoderReranker:
             raise error_container[0]
         return result_container[0] if result_container else ""
 
-    def _kill_worker(self) -> None:
+    def _kill_worker(self, timeout: float = 3.0) -> None:
         """Terminate the worker and close every owned pipe exactly once."""
         if self._idle_timer is not None:
             self._idle_timer.cancel()
@@ -337,10 +417,16 @@ class CrossEncoderReranker:
             # Detach first so re-entrant/finalizer cleanup is idempotent.
             self._worker_proc = None
             self._worker_ready = False
+            # Invariant: a dead worker has no loaded model. Enforcing this in
+            # ONE place (not just the recycle/timeout callers) means the idle
+            # timer's kill also clears the flag, so the recall path sees the
+            # gap and triggers a background re-warmup instead of sending a
+            # rerank to a cold worker and risking a 15s-timeout churn.
+            self._model_loaded = False
             try:
                 proc.stdin.write('{"cmd":"quit"}\n')
                 proc.stdin.flush()
-                proc.wait(timeout=3)
+                proc.wait(timeout=max(0.0, timeout))
             except Exception:
                 try:
                     returncode = proc.poll()
@@ -349,7 +435,7 @@ class CrossEncoderReranker:
                 if returncode is None or not isinstance(returncode, int):
                     try:
                         proc.kill()
-                        proc.wait(timeout=3)
+                        proc.wait(timeout=max(0.0, timeout))
                     except Exception:
                         pass
             finally:
@@ -365,6 +451,8 @@ class CrossEncoderReranker:
 
     def _reset_idle_timer(self) -> None:
         """Reset idle timer — kills worker after 2 min inactivity."""
+        if self._shutdown_event.is_set():
+            return
         if self._idle_timer is not None:
             self._idle_timer.cancel()
         self._idle_timer = threading.Timer(
@@ -379,6 +467,16 @@ class CrossEncoderReranker:
             self._kill_worker()
             logger.info("CrossEncoderReranker: worker killed (idle timeout)")
 
+    def shutdown(self, timeout: float = 3.0) -> None:
+        """Cancel warmup, terminate the child, and join owned background work."""
+        shutdown_event = getattr(self, "_shutdown_event", None)
+        if shutdown_event is not None:
+            shutdown_event.set()
+        self._kill_worker(timeout=min(max(0.0, timeout), 1.0))
+        warmup_thread = getattr(self, "_warmup_thread", None)
+        if warmup_thread is not None and warmup_thread is not threading.current_thread():
+            warmup_thread.join(timeout=timeout)
+
     # ------------------------------------------------------------------
     # Public API
     # ------------------------------------------------------------------
@@ -411,8 +509,18 @@ class CrossEncoderReranker:
         if not candidates:
             return [], False, "no_candidates"
 
-        # Non-blocking: if model isn't loaded yet, return fallback
+        # Non-blocking: if the model isn't loaded, return fallback AND kick a
+        # background (re)warmup so the reranker SELF-HEALS.  Without this, a
+        # worker that was recycled (every 500 reqs), idle-killed (30 min), or
+        # crashed left ``_model_loaded`` False with nothing to reload it — every
+        # subsequent recall degraded to fallback scoring until the daemon was
+        # restarted (a silent, sustained quality regression).  The warmup is
+        # guarded (no-op if already loading/loaded), retried, and never blocks
+        # this recall — it returns fallback now and full quality resumes within
+        # seconds once the model is warm again.
         if not self._model_loaded:
+            if not self._shutdown_event.is_set() and not self._worker_loading:
+                self._start_background_warmup()
             sorted_cands = sorted(candidates, key=lambda x: x[1], reverse=True)
             return sorted_cands[:top_k], False, "fallback_not_ready"
 
@@ -479,7 +587,7 @@ def _cleanup_all_rerankers() -> None:
         reranker = ref()
         if reranker is not None:
             try:
-                reranker._kill_worker()
+                reranker.shutdown()
             except Exception:
                 pass
     _live_rerankers.clear()

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -224,8 +224,13 @@ class SpreadingActivation:
             if not self._fok_check(activations):
                 return []
 
-            # Cache results
-            self._cache_results(query_hash, profile_id, activations)
+            # Cache results — DEFERRED so recall stays READ-ONLY on its hot
+            # path.  This is a perf cache for FUTURE recalls, not needed to
+            # return the current results.
+            from superlocalmemory.storage.deferred_writes import submit_background
+            submit_background(
+                lambda: self._cache_results(query_hash, profile_id, activations)
+            )
 
             # Return top-K sorted by activation
             results = sorted(
@@ -545,16 +550,19 @@ class SpreadingActivation:
     ) -> None:
         """Store results in activation_cache with 1-hour TTL."""
         try:
-            for node_id, value in activations.items():
-                self._db.execute(
-                    "INSERT OR REPLACE INTO activation_cache "
-                    "(cache_id, profile_id, query_hash, node_id, "
-                    " activation_value, iteration, created_at, expires_at) "
-                    "VALUES (?, ?, ?, ?, ?, ?, datetime('now'), "
-                    "datetime('now', '+1 hour'))",
-                    (_new_id(), profile_id, query_hash, node_id, value,
-                     self._config.max_iterations),
-                )
+            # One transaction => ONE write-lock acquisition for the whole
+            # activation cache, instead of N separately-locked writes.
+            with self._db.transaction():
+                for node_id, value in activations.items():
+                    self._db.execute(
+                        "INSERT OR REPLACE INTO activation_cache "
+                        "(cache_id, profile_id, query_hash, node_id, "
+                        " activation_value, iteration, created_at, expires_at) "
+                        "VALUES (?, ?, ?, ?, ?, ?, datetime('now'), "
+                        "datetime('now', '+1 hour'))",
+                        (_new_id(), profile_id, query_hash, node_id, value,
+                         self._config.max_iterations),
+                    )
         except Exception as exc:
             logger.debug("Cache write failed: %s", exc)
 

package/src/superlocalmemory/retrieval/vector_store.py

@@ -23,6 +23,8 @@ from typing import Any
 
 import numpy as np
 
+from superlocalmemory.storage.write_lock import get_write_lock
+
 logger = logging.getLogger(__name__)
 
 
@@ -182,51 +184,62 @@ class VectorStore:
             )
             return False
 
+        # Embedding bytes computed OUTSIDE the lock — serialisation must not
+        # cover slow computation, only the sqlite3 write transaction itself.
         vec_bytes = self._serialize_f32(embedding)
 
-        with self._lock:
-            try:
-                conn = self._connect()
-                # Check if fact_id already exists in metadata
-                row = conn.execute(
-                    "SELECT vec_rowid FROM embedding_metadata "
-                    "WHERE fact_id = ?",
-                    (fact_id,),
-                ).fetchone()
-
-                if row is not None:
-                    # UPDATE existing
-                    rowid = row["vec_rowid"]
-                    conn.execute(
-                        "UPDATE fact_embeddings SET embedding = ? "
-                        "WHERE rowid = ?",
-                        (vec_bytes, rowid),
-                    )
-                else:
-                    # INSERT new
-                    conn.execute(
-                        "INSERT INTO fact_embeddings(profile_id, embedding) "
-                        "VALUES (?, ?)",
-                        (profile_id, vec_bytes),
-                    )
-                    rowid = conn.execute(
-                        "SELECT last_insert_rowid()"
-                    ).fetchone()[0]
-                    conn.execute(
-                        "INSERT INTO embedding_metadata "
-                        "(vec_rowid, fact_id, profile_id, model_name, dimension) "
-                        "VALUES (?, ?, ?, ?, ?)",
-                        (rowid, fact_id, profile_id,
-                         model_name or self._config.model_name,
-                         self._config.dimension),
-                    )
-
-                conn.commit()
-                conn.close()
-                return True
-            except Exception as exc:
-                logger.debug("upsert failed for fact_id=%s: %s", fact_id, exc)
-                return False
+        # Acquire the process-level write lock for this db file BEFORE opening
+        # the sqlite3 connection.  This is the OUTERMOST lock (see write_lock.py
+        # ordering rule).  self._lock is INNER and acquired inside.  The write
+        # lock is the same RLock that DatabaseManager._lock references for this
+        # db_path, so the self-heal backfill pattern
+        #   with db._lock: vs.upsert()
+        # simply re-enters the RLock (same thread — always safe).
+        _wl = get_write_lock(self._db_path)
+        with _wl:            # OUTER: serialises all memory.db writers
+            with self._lock:  # INNER: VectorStore per-instance state
+                try:
+                    conn = self._connect()
+                    # Check if fact_id already exists in metadata
+                    row = conn.execute(
+                        "SELECT vec_rowid FROM embedding_metadata "
+                        "WHERE fact_id = ?",
+                        (fact_id,),
+                    ).fetchone()
+
+                    if row is not None:
+                        # UPDATE existing
+                        rowid = row["vec_rowid"]
+                        conn.execute(
+                            "UPDATE fact_embeddings SET embedding = ? "
+                            "WHERE rowid = ?",
+                            (vec_bytes, rowid),
+                        )
+                    else:
+                        # INSERT new
+                        conn.execute(
+                            "INSERT INTO fact_embeddings(profile_id, embedding) "
+                            "VALUES (?, ?)",
+                            (profile_id, vec_bytes),
+                        )
+                        rowid = conn.execute(
+                            "SELECT last_insert_rowid()"
+                        ).fetchone()[0]
+                        conn.execute(
+                            "INSERT INTO embedding_metadata "
+                            "(vec_rowid, fact_id, profile_id, model_name, dimension) "
+                            "VALUES (?, ?, ?, ?, ?)",
+                            (rowid, fact_id, profile_id,
+                             model_name or self._config.model_name,
+                             self._config.dimension),
+                        )
+
+                    conn.commit()
+                    conn.close()
+                    return True
+                except Exception as exc:
+                    logger.debug("upsert failed for fact_id=%s: %s", fact_id, exc)
+                    return False
 
     def search(
         self,
@@ -302,41 +315,43 @@ class VectorStore:
     def delete(self, fact_id: str) -> bool:
         """Remove a vector from vec0 and metadata.
 
-        Thread-safe: acquires self._lock.
+        Thread-safe: acquires the process-level write lock then self._lock.
         Returns True if deleted, False if not found or error.
         """
         if not self._available:
             return False
 
-        with self._lock:
-            try:
-                conn = self._connect()
-                row = conn.execute(
-                    "SELECT vec_rowid FROM embedding_metadata "
-                    "WHERE fact_id = ?",
-                    (fact_id,),
-                ).fetchone()
+        _wl = get_write_lock(self._db_path)
+        with _wl:            # OUTER: process-level write serialisation
+            with self._lock:  # INNER: VectorStore per-instance state
+                try:
+                    conn = self._connect()
+                    row = conn.execute(
+                        "SELECT vec_rowid FROM embedding_metadata "
+                        "WHERE fact_id = ?",
+                        (fact_id,),
+                    ).fetchone()
+
+                    if row is None:
+                        conn.close()
+                        return False
 
-                if row is None:
+                    rowid = row["vec_rowid"]
+                    conn.execute(
+                        "DELETE FROM fact_embeddings WHERE rowid = ?",
+                        (rowid,),
+                    )
+                    conn.execute(
+                        "DELETE FROM embedding_metadata WHERE vec_rowid = ?",
+                        (rowid,),
+                    )
+                    conn.commit()
                     conn.close()
+                    return True
+                except Exception as exc:
+                    logger.debug("delete failed for fact_id=%s: %s", fact_id, exc)
                     return False
 
-                rowid = row["vec_rowid"]
-                conn.execute(
-                    "DELETE FROM fact_embeddings WHERE rowid = ?",
-                    (rowid,),
-                )
-                conn.execute(
-                    "DELETE FROM embedding_metadata WHERE vec_rowid = ?",
-                    (rowid,),
-                )
-                conn.commit()
-                conn.close()
-                return True
-            except Exception as exc:
-                logger.debug("delete failed for fact_id=%s: %s", fact_id, exc)
-                return False
-
     def count(self, profile_id: str | None = None) -> int:
         """Count vectors in the store.
 

package/src/superlocalmemory/server/loopback.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""Centralized loopback-address predicate for the SLM server.
+
+Replaces every ``frozenset({"127.0.0.1", "::1", "localhost"})`` auth check
+with a semantic helper that correctly handles IPv4-mapped IPv6 addresses
+(``::ffff:127.0.0.1``) — the root cause of issue #90.
+
+Issue #90 root cause
+--------------------
+When the daemon is started with ``SLM_DAEMON_HOST=0.0.0.0`` on a dual-stack
+Linux host (common in LXC/Docker containers), the OS creates an IPv6 socket
+that accepts IPv4 connections via the IPv4-mapped IPv6 address mechanism
+(RFC 4291 §2.5.5.2). A client connecting to ``localhost`` on such a host
+may have its peer address reported as ``::ffff:127.0.0.1`` by
+uvicorn/Starlette. The literal set ``("127.0.0.1", "::1", "localhost")``
+does not include this form, causing a spurious 403 for install-token and
+uncredentialed-loopback callers.
+
+``ipaddress.ip_address("::ffff:127.0.0.1").is_loopback`` already returns
+``True`` in CPython. This module uses that fact.
+
+SECURITY INVARIANTS (non-negotiable):
+  - Empty/None host → False. SEC-L-02: a missing peer is never trusted.
+  - No proxy header trust. Callers MUST pass ``request.client.host`` only,
+    never X-Forwarded-For or any other spoofable header.
+  - All 127.0.0.0/8 is loopback per RFC 5735 (includes 127.0.0.2, etc.).
+  - ``"localhost"`` is accepted as a hostname alias. Callers that need the
+    stricter no-hostname check (``prewarm_auth``) keep their own predicate.
+  - ``"testclient"`` is NOT in the loopback set — that bypass must be wired
+    explicitly alongside ``_TEST_ISOLATION_ALLOWED`` so it cannot appear in
+    production paths.
+  - ``"0.0.0.0"`` is NOT loopback — it is a bind address, not a peer address.
+"""
+
+from __future__ import annotations
+
+import ipaddress as _ipa
+
+
+def is_loopback(host: str) -> bool:
+    """Return ``True`` iff ``host`` is a loopback address in any standard form.
+
+    Handles:
+    * ``"127.0.0.1"`` and the full 127.0.0.0/8 range (RFC 5735).
+    * ``"::1"`` (IPv6 loopback).
+    * ``"::ffff:127.0.0.1"`` and all ``::ffff:127.x.x.x`` (IPv4-mapped IPv6,
+      fixes issue #90).
+    * ``"localhost"`` (hostname alias, case-insensitive).
+
+    Returns ``False`` for:
+    * Empty string or ``None`` (SEC-L-02: missing peer is never trusted).
+    * Any non-loopback IP (192.168.x.x, 10.x.x.x, public IPs, etc.).
+    * ``"::ffff:192.168.x.x"`` and other IPv4-mapped non-loopback addresses.
+    * ``"testclient"`` — callers that need the test-client exemption must
+      wire it explicitly alongside ``_TEST_ISOLATION_ALLOWED``.
+    * ``"0.0.0.0"`` — bind address, not a peer address.
+
+    Args:
+        host: The ``request.client.host`` string from an incoming HTTP
+            request. Must be the TCP-observed peer address only.
+
+    Returns:
+        ``True`` if the host is any recognised loopback form; ``False``
+        otherwise.
+    """
+    if not isinstance(host, str) or not host:
+        return False  # SEC-L-02
+    if host.lower() == "localhost":
+        return True
+    try:
+        ip = _ipa.ip_address(host)
+    except ValueError:
+        return False
+    if ip.is_loopback:
+        return True
+    # CPython's handling of IPv4-mapped IPv6 changed across supported
+    # runtimes. Normalize through the embedded IPv4 address so a dual-stack
+    # socket reporting ::ffff:127.x.x.x retains the equivalent IPv4 decision.
+    mapped_ipv4 = getattr(ip, "ipv4_mapped", None)
+    return bool(mapped_ipv4 is not None and mapped_ipv4.is_loopback)
+
+
+__all__ = ("is_loopback",)

package/src/superlocalmemory/server/origin.py

@@ -4,12 +4,17 @@ from __future__ import annotations
 
 from urllib.parse import urlsplit
 
-
-_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
 
 
 def origin_is_loopback(origin: str) -> bool:
-    """Return whether an Origin is absent or an exact HTTP(S) loopback URL."""
+    """Return whether an Origin is absent or an exact HTTP(S) loopback URL.
+
+    Uses the centralized is_loopback helper so that IPv4-mapped loopback
+    addresses (::ffff:127.x.x.x) are accepted correctly (issue #90).
+    Note: browsers normalize Origin hostnames; the ::ffff: form would only
+    appear in synthetic requests. The helper is used for defense-in-depth.
+    """
     if not origin:
         return True
     try:
@@ -21,7 +26,7 @@ def origin_is_loopback(origin: str) -> bool:
     return (
         parsed.scheme in {"http", "https"}
         and parsed.hostname is not None
-        and parsed.hostname.lower() in _LOOPBACK_HOSTS
+        and _is_loopback_host(parsed.hostname.lower())
         and parsed.username is None
         and parsed.password is None
         and parsed.path in {"", "/"}

package/src/superlocalmemory/server/profile_runtime.py

@@ -361,6 +361,13 @@ def commit_daemon_profile_switch(
         # Rebind the in-memory engine first, then make compatibility files the
         # final commit step so they can never lead daemon runtime truth.
         engine.profile_id = target_profile
+        canonical_remember = getattr(
+            app_state,
+            "canonical_remember_runtime",
+            None,
+        )
+        if canonical_remember is not None:
+            canonical_remember.rebind_engine(engine)
         if app_config is not None:
             app_config.active_profile = target_profile
         if engine_config is not None:
@@ -368,6 +375,13 @@ def commit_daemon_profile_switch(
         persistence = persist_active_profile(target_profile)
     except BaseException:
         engine.profile_id = previous.profile_id
+        canonical_remember = getattr(
+            app_state,
+            "canonical_remember_runtime",
+            None,
+        )
+        if canonical_remember is not None:
+            canonical_remember.rebind_engine(engine)
         if app_config is not None:
             app_config.active_profile = previous.profile_id
         if engine_config is not None:

package/src/superlocalmemory/server/routes/abstraction.py

@@ -24,7 +24,7 @@ from typing import Any
 from fastapi import APIRouter, Query
 from fastapi.responses import JSONResponse
 
-from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
+from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile, get_read_connection
 
 logger = logging.getLogger(__name__)
 
@@ -45,9 +45,7 @@ class _ReadDB:
 def _conn() -> sqlite3.Connection | None:
     if not DB_PATH.exists():
         return None
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    return conn
+    return get_read_connection(DB_PATH)
 
 
 @router.get("/persona")