superlocalmemory 3.8.5 → 3.8.7

package/src/superlocalmemory/optimize/proxy/capture.py

@@ -9,7 +9,8 @@ Activation: set ``SLM_OPTIMIZE_CAPTURE=1`` in the daemon's environment. When on:
     at load time (see server._load_hooks), so capture never observes a mutated
     request or a cache hit; every line is a genuine upstream exchange.
   * each completed exchange is appended as one JSON line to
-    ``~/.superlocalmemory/optimize_capture.jsonl`` (0600, gitignored).
+    ``~/.superlocalmemory/optimize_capture.jsonl`` (owner-only: POSIX 0600 or
+    Windows owner DACL, gitignored).
 
 ISOLATION GUARANTEE: this module writes ONLY to optimize_capture.jsonl. It never
 opens memory.db, llmcache.db, or any SLM memory store. (Plan §9 hard rule.)
@@ -21,9 +22,11 @@ swallowed — it MUST NOT break the proxied request the user is waiting on.
 from __future__ import annotations
 
 import asyncio
+import errno
 import json
 import logging
 import os
+import stat
 import threading
 from pathlib import Path
 from typing import Any
@@ -55,6 +58,180 @@ def _capture_path() -> Path:
     return state_path(_CAPTURE_FILENAME)
 
 
+def _is_windows() -> bool:
+    """Return whether the running platform uses Windows DACLs."""
+    return os.name == "nt"
+
+
+def _is_link_or_reparse(info: os.stat_result) -> bool:
+    """Reject POSIX symlinks and Windows reparse points before capture."""
+    reparse = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0)
+    attributes = getattr(info, "st_file_attributes", 0)
+    return stat.S_ISLNK(info.st_mode) or bool(reparse and attributes & reparse)
+
+
+def _windows_owner_dacl(
+    win32api: Any,
+    win32con: Any,
+    win32security: Any,
+) -> Any:
+    """Build one protected owner-only DACL for a Windows capture file."""
+    import ntsecuritycon
+
+    token = win32security.OpenProcessToken(
+        win32api.GetCurrentProcess(),
+        win32con.TOKEN_QUERY,
+    )
+    try:
+        owner_sid = win32security.GetTokenInformation(
+            token,
+            win32security.TokenUser,
+        )[0]
+    finally:
+        token.Close()
+    dacl = win32security.ACL()
+    dacl.AddAccessAllowedAce(
+        win32security.ACL_REVISION,
+        ntsecuritycon.FILE_ALL_ACCESS,
+        owner_sid,
+    )
+    return dacl
+
+
+def _open_windows_capture_append(path: Path) -> int:
+    """Create/open a Windows file with append + WRITE_DAC on one handle."""
+    try:
+        import msvcrt
+
+        import ntsecuritycon
+        import win32api
+        import win32con
+        import win32file
+        import win32security
+    except ImportError as exc:
+        raise OSError("Windows capture ACL support is unavailable") from exc
+
+    handle = None
+    try:
+        # A creation-time descriptor prevents a newly created capture file from
+        # ever inheriting a broader parent DACL. For an existing file Windows
+        # ignores this descriptor; _enforce_owner_only_permissions replaces
+        # that DACL through the same WRITE_DAC-capable handle before writing.
+        dacl = _windows_owner_dacl(win32api, win32con, win32security)
+        security_attributes = win32security.SECURITY_ATTRIBUTES()
+        security_attributes.bInheritHandle = False
+        security_attributes.SECURITY_DESCRIPTOR.SetSecurityDescriptorDacl(
+            1,
+            dacl,
+            0,
+        )
+        security_attributes.SECURITY_DESCRIPTOR.SetSecurityDescriptorControl(
+            win32security.SE_DACL_PROTECTED,
+            win32security.SE_DACL_PROTECTED,
+        )
+        handle = win32file.CreateFile(
+            os.fspath(path),
+            ntsecuritycon.FILE_APPEND_DATA | ntsecuritycon.WRITE_DAC,
+            win32con.FILE_SHARE_READ
+            | win32con.FILE_SHARE_WRITE
+            | win32con.FILE_SHARE_DELETE,
+            security_attributes,
+            win32con.OPEN_ALWAYS,
+            win32con.FILE_ATTRIBUTE_NORMAL
+            # pywin32 does not export this SDK constant from win32con on
+            # every supported Python build. Keep the Microsoft-defined value
+            # as a named fallback rather than silently following a reparse.
+            | getattr(win32con, "FILE_FLAG_OPEN_REPARSE_POINT", 0x00200000),
+            None,
+        )
+        file_info = win32file.GetFileInformationByHandle(handle)
+        if file_info[0] & win32con.FILE_ATTRIBUTE_REPARSE_POINT:
+            raise OSError(
+                errno.ELOOP,
+                "capture path is a Windows reparse point",
+                path,
+            )
+        try:
+            # Enforce the DACL while this is still the original CreateFile
+            # handle carrying WRITE_DAC. Transferring it into Python's CRT
+            # first can lose the authority SetSecurityInfo needs on Windows.
+            win32security.SetSecurityInfo(
+                handle,
+                win32security.SE_FILE_OBJECT,
+                win32security.DACL_SECURITY_INFORMATION
+                | win32security.PROTECTED_DACL_SECURITY_INFORMATION,
+                None,
+                None,
+                dacl,
+                None,
+            )
+        except Exception as exc:
+            raise OSError(
+                "Windows capture ACL could not be enforced "
+                f"({type(exc).__name__}: {exc})"
+            ) from exc
+
+        # Transfer the native handle to Python's CRT descriptor exactly once.
+        raw_handle = handle.Detach()
+        handle = None
+        try:
+            return msvcrt.open_osfhandle(
+                raw_handle,
+                os.O_WRONLY | os.O_APPEND | getattr(os, "O_BINARY", 0),
+            )
+        except BaseException:
+            win32api.CloseHandle(raw_handle)
+            raise
+    except OSError:
+        raise
+    except Exception as exc:
+        raise OSError(f"Windows secure capture open failed: {exc}") from exc
+    finally:
+        if handle is not None:
+            handle.Close()
+
+
+def _open_capture_append(path: Path) -> int:
+    """Open one append descriptor without following or racing a link target."""
+    try:
+        before = path.lstat()
+    except FileNotFoundError:
+        before = None
+    if before is not None and _is_link_or_reparse(before):
+        raise OSError(errno.ELOOP, "capture path is a link or reparse point", path)
+
+    if _is_windows():
+        fd = _open_windows_capture_append(path)
+    else:
+        flags = os.O_CREAT | os.O_WRONLY | os.O_APPEND | getattr(os, "O_NOFOLLOW", 0)
+        fd = os.open(path, flags, 0o600)
+    try:
+        opened = os.fstat(fd)
+        current = path.lstat()
+        if (
+            _is_link_or_reparse(current)
+            or (opened.st_dev, opened.st_ino) != (current.st_dev, current.st_ino)
+        ):
+            raise OSError(
+                errno.ELOOP,
+                "capture path changed during secure open",
+                path,
+            )
+    except BaseException:
+        os.close(fd)
+        raise
+    return fd
+
+
+def _enforce_owner_only_permissions(fd: int) -> None:
+    """Apply owner-only access control through the already-verified handle."""
+    if not _is_windows():
+        os.fchmod(fd, 0o600)
+        return
+    # _open_windows_capture_append applies the protected DACL on the original
+    # WRITE_DAC-capable CreateFile handle before CRT descriptor transfer.
+
+
 class ShadowCapture:
     """Thread-safe append-only JSONL writer for proxy exchanges (singleton)."""
 
@@ -95,10 +272,10 @@ class ShadowCapture:
         Fail-open: any error is logged and False is returned; never raised.
 
         Security: opens with a single ``os.open`` carrying ``O_CREAT |
-        O_APPEND | O_NOFOLLOW`` and mode ``0o600`` on EVERY write. O_NOFOLLOW
-        refuses a symlink pre-placed at the path (symlink-append attack), and
-        the unconditional 0600-on-create removes the stat/exists TOCTOU that
-        could otherwise drop the file to the process umask.
+        O_APPEND`` and mode ``0o600`` on every write. POSIX adds O_NOFOLLOW;
+        all platforms reject link/reparse metadata and verify that the opened
+        descriptor still identifies the current path. Permissions are then
+        enforced through that verified descriptor before any data is written.
         """
         try:
             line = json.dumps(entry, ensure_ascii=False, separators=(",", ":"))
@@ -109,9 +286,20 @@ class ShadowCapture:
         try:
             with self._write_lock:
                 self._path.parent.mkdir(parents=True, exist_ok=True)
-                flags = os.O_CREAT | os.O_WRONLY | os.O_APPEND | getattr(os, "O_NOFOLLOW", 0)
-                fd = os.open(self._path, flags, 0o600)
-                with os.fdopen(fd, "a", encoding="utf-8") as fh:
+                fd = _open_capture_append(self._path)
+                try:
+                    # Enforce the ACL through the verified descriptor so a
+                    # pathname swap cannot redirect chmod/icacls elsewhere.
+                    _enforce_owner_only_permissions(fd)
+                    # fdopen transfers descriptor ownership only after it
+                    # returns successfully. Keep this conversion inside the
+                    # explicit-close boundary so an allocation/codec failure
+                    # cannot leak one descriptor per captured request.
+                    fh = os.fdopen(fd, "a", encoding="utf-8")
+                except BaseException:
+                    os.close(fd)
+                    raise
+                with fh:
                     fh.write(line + "\n")
                 self._count += 1
             return True

package/src/superlocalmemory/retrieval/engine.py

@@ -904,13 +904,18 @@ class RetrievalEngine:
 
         return out
 
-    def close(self) -> None:
-        """Release the channel workers owned by this retrieval engine."""
+    def close(self, *, wait: bool = False) -> None:
+        """Release owned channel workers without blocking daemon shutdown.
+
+        Active channel calls have their own response deadline.  Waiting here
+        can still deadlock shutdown when an extension ignores that deadline,
+        so the daemon uses the executor's non-blocking cancellation path.
+        """
         with self._close_lock:
             if self._closed:
                 return
             self._closed = True
-        self._channel_executor.shutdown(wait=True, cancel_futures=True)
+        self._channel_executor.shutdown(wait=wait, cancel_futures=True)
 
     # -- Fact loading -------------------------------------------------------
 

package/src/superlocalmemory/retrieval/reranker.py

@@ -111,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
 
@@ -126,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
 
@@ -142,14 +144,14 @@ 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:
                 for attempt in range(1, _WARMUP_MAX_ATTEMPTS + 1):
-                    if self._model_loaded:
+                    if self._shutdown_event.is_set() or self._model_loaded:
                         return
                     try:
                         self._ensure_worker()
@@ -206,7 +208,10 @@ class CrossEncoderReranker:
                         )
 
                     if attempt < _WARMUP_MAX_ATTEMPTS and not self._model_loaded:
-                        time.sleep(min(_WARMUP_RETRY_BACKOFF_S * attempt, 15.0))
+                        if self._shutdown_event.wait(
+                            min(_WARMUP_RETRY_BACKOFF_S * attempt, 15.0),
+                        ):
+                            return
 
                 if not self._model_loaded:
                     logger.warning(
@@ -231,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:
@@ -248,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
@@ -327,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)
@@ -393,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()
@@ -413,7 +426,7 @@ class CrossEncoderReranker:
             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()
@@ -422,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:
@@ -438,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(
@@ -452,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
     # ------------------------------------------------------------------
@@ -494,7 +519,7 @@ class CrossEncoderReranker:
         # 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._worker_loading:
+            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"
@@ -562,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/server/loopback.py

@@ -39,15 +39,6 @@ from __future__ import annotations
 import ipaddress as _ipa
 
 
-# CRIT-2 guard: detect a future CPython regression where IPv4-mapped loopback
-# is no longer reported as .is_loopback. Fails at daemon startup (import time),
-# not silently at request time.
-assert _ipa.ip_address("::ffff:127.0.0.1").is_loopback, (
-    "Python ipaddress regression: ::ffff:127.0.0.1 no longer reports as "
-    "loopback. Update superlocalmemory/server/loopback.py. (Issue #90)"
-)
-
-
 def is_loopback(host: str) -> bool:
     """Return ``True`` iff ``host`` is a loopback address in any standard form.
 
@@ -82,10 +73,13 @@ def is_loopback(host: str) -> bool:
         ip = _ipa.ip_address(host)
     except ValueError:
         return False
-    # Python's .is_loopback already handles 127.0.0.0/8, ::1, and
-    # IPv4-mapped loopback (::ffff:127.x.x.x). No manual ipv4_mapped
-    # normalization needed — the stdlib does the right thing.
-    return ip.is_loopback
+    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/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")

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

@@ -14,7 +14,7 @@ from fastapi import APIRouter, HTTPException, Query, Request
 
 from superlocalmemory.infra.data_root import state_path
 
-from .helpers import DB_PATH
+from .helpers import DB_PATH, get_read_connection
 
 logger = logging.getLogger("superlocalmemory.routes.agents")
 router = APIRouter()
@@ -103,8 +103,7 @@ async def get_agent_memory_activity(
     total = 0
 
     if DB_PATH.exists():
-        conn = sqlite3.connect(str(DB_PATH))
-        conn.row_factory = sqlite3.Row
+        conn = get_read_connection(DB_PATH)
         try:
             try:
                 rows = conn.execute(
@@ -188,8 +187,7 @@ async def get_trust_stats(request: Request):
         by_signal_type = {}
 
         if DB_PATH.exists():
-            conn = sqlite3.connect(str(DB_PATH))
-            conn.row_factory = sqlite3.Row
+            conn = get_read_connection(DB_PATH)
             try:
                 try:
                     # Count trust signals

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

@@ -18,6 +18,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 
 from .helpers import MEMORY_DIR, get_active_profile
 from superlocalmemory.storage.memory_write import memory_write
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
 logger = logging.getLogger("superlocalmemory.routes.behavioral")
 router = APIRouter()
@@ -146,8 +147,7 @@ def _load_action_outcomes(profile_id: str) -> dict:
     if not db_path.exists():
         return empty
     try:
-        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True, timeout=1.0)
-        conn.row_factory = sqlite3.Row
+        conn = ReadConnectionFactory(db_path).open()
         try:
             columns = {
                 str(row["name"])
@@ -369,7 +369,6 @@ def report_outcome(request: Request, data: ReportOutcomeRequest):
     action_type = data.action_type
     context_note = data.context
 
-    import sqlite3
     import uuid
     from datetime import datetime, timezone
 
@@ -451,10 +450,8 @@ def get_assertions(
 ):
     """Get learned behavioral assertions for dashboard display."""
     try:
-        import sqlite3 as _sqlite3
         profile = get_active_profile()
-        conn = _sqlite3.connect(str(MEMORY_DIR / "memory.db"))
-        conn.row_factory = _sqlite3.Row
+        conn = ReadConnectionFactory(MEMORY_DIR / "memory.db").open()
 
         query = (
             "SELECT id, trigger_condition, action, category, confidence, "
@@ -495,10 +492,8 @@ def get_tool_events(
 ):
     """Get recent tool events for dashboard display."""
     try:
-        import sqlite3 as _sqlite3
         profile = get_active_profile()
-        conn = _sqlite3.connect(str(MEMORY_DIR / "memory.db"))
-        conn.row_factory = _sqlite3.Row
+        conn = ReadConnectionFactory(MEMORY_DIR / "memory.db").open()
 
         query = (
             "SELECT id, tool_name, event_type, input_summary, output_summary, "
@@ -528,10 +523,8 @@ def get_soft_prompts(request: Request):
     """Get active soft prompt templates for dashboard display."""
     _require_read(request)
     try:
-        import sqlite3 as _sqlite3
         profile = get_active_profile()
-        conn = _sqlite3.connect(str(MEMORY_DIR / "memory.db"))
-        conn.row_factory = _sqlite3.Row
+        conn = ReadConnectionFactory(MEMORY_DIR / "memory.db").open()
         rows = conn.execute(
             "SELECT prompt_id, category, content, confidence, effectiveness, "
             "token_count, active, version, created_at "
@@ -570,7 +563,6 @@ def log_tool_event_api(request: Request, data: dict):
     _require_write(request)
     try:
         import os
-        import sqlite3 as _sqlite3
         from datetime import datetime, timezone
 
         tool_name = data.get("tool_name", "unknown")

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

@@ -60,6 +60,7 @@ from superlocalmemory.core.security_primitives import (
 from superlocalmemory.learning.database import LearningDatabase
 from superlocalmemory.learning.features import FEATURE_DIM
 from superlocalmemory.infra.data_root import canonical_data_root
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 from .helpers import get_active_profile
 
 logger = logging.getLogger("superlocalmemory.routes.brain")
@@ -554,7 +555,7 @@ def _compute_cache_stats() -> dict:
     size = db.stat().st_size
     entry_count = 0
     try:
-        conn = sqlite3.connect(str(db), timeout=5.0)
+        conn = ReadConnectionFactory(db).open()
         try:
             row = conn.execute(
                 "SELECT COUNT(*) AS cnt FROM atomic_facts",
@@ -579,14 +580,11 @@ def _adapter_last_sync_ago(adapter_name: str) -> int | None:
     honest empty rather than a fabricated number.
     """
     try:
-        import sqlite3 as _sqlite3
         from datetime import datetime as _dt, timezone as _tz
         memory_db = _memory_dir() / "memory.db"
         if not memory_db.exists():
             return None
-        conn = _sqlite3.connect(
-            f"file:{memory_db}?mode=ro", uri=True, timeout=1.0,
-        )
+        conn = ReadConnectionFactory(memory_db).open()
         try:
             cur = conn.execute(
                 "SELECT last_sync_at FROM cross_platform_sync_log "
@@ -914,7 +912,7 @@ def _compute_action_outcomes_preview(profile_id: str) -> dict:
     if not db_path.exists():
         return empty
     try:
-        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True, timeout=1.0)
+        conn = ReadConnectionFactory(db_path).open()
         try:
             row = conn.execute(
                 "SELECT COUNT(*) FROM action_outcomes WHERE profile_id = ?",
@@ -1036,7 +1034,6 @@ def _compute_outcome_queue_stats(profile_id: str) -> dict:
     ``pending_outcomes`` so the operator can see the closed loop is
     actually flowing: recall → enqueue → persist → finalize.
     """
-    import sqlite3
     try:
         from superlocalmemory.learning.outcome_queue import (
             get_counters, queue_size,
@@ -1050,7 +1047,7 @@ def _compute_outcome_queue_stats(profile_id: str) -> dict:
     pending_now = 0
     if db.exists():
         try:
-            conn = sqlite3.connect(str(db), timeout=1.0)
+            conn = ReadConnectionFactory(db).open()
             try:
                 row = conn.execute(
                     "SELECT COUNT(*) FROM pending_outcomes "
@@ -1089,7 +1086,7 @@ def _compute_reward_preview(profile_id: str) -> dict:
     if not db.exists():
         return default
     try:
-        conn = sqlite3.connect(str(db), timeout=1.0)
+        conn = ReadConnectionFactory(db).open()
         try:
             row = conn.execute(
                 "SELECT COUNT(*) AS c, AVG(reward) AS m "