superlocalmemory 3.8.3 → 3.8.6

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/backup.py

@@ -87,9 +87,13 @@ def _require_oauth_start(request: Request) -> None:
             detail="OAuth initiation requires the local dashboard origin.",
         )
 
+    from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
+
     host = request.client.host if request.client else ""
-    is_loopback = host in {"127.0.0.1", "::1", "localhost", "testclient"}
-    if not is_loopback and principal.get("kind") != "user":
+    # "testclient" is included for in-process test compatibility (preserved
+    # from original behaviour; was in the original frozenset).
+    _from_loopback = _is_loopback_host(host) or host == "testclient"
+    if not _from_loopback and principal.get("kind") != "user":
         raise HTTPException(
             status_code=403,
             detail=(

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

@@ -17,6 +17,8 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Request
 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()
@@ -145,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"])
@@ -368,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
 
@@ -385,10 +385,9 @@ def report_outcome(request: Request, data: ReportOutcomeRequest):
             "action_type": action_type,
             "source": "dashboard_report_outcome",
         }
-        conn = sqlite3.connect(str(memory_db_path), timeout=5.0)
-        try:
-            conn.execute("PRAGMA busy_timeout=5000")
-            conn.execute("BEGIN IMMEDIATE")
+        # memory_write acquires the process write lock (serialises in-process)
+        # and sets PRAGMA busy_timeout (cross-process writers wait, not error).
+        with memory_write(memory_db_path) as conn:
             _validate_profile_fact_ids(
                 conn,
                 profile_id=profile,
@@ -407,9 +406,6 @@ def report_outcome(request: Request, data: ReportOutcomeRequest):
                     now_iso, reward, now_iso,
                 ),
             )
-            conn.commit()
-        finally:
-            conn.close()
 
         try:
             from superlocalmemory.learning.source_quality import (
@@ -454,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, "
@@ -498,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, "
@@ -531,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 "
@@ -573,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")
@@ -589,8 +578,8 @@ def log_tool_event_api(request: Request, data: dict):
         input_summary = str(input_summary)[:500] if input_summary else ""
         output_summary = str(output_summary)[:500] if output_summary else ""
 
-        conn = _sqlite3.connect(str(MEMORY_DIR / "memory.db"))
-        try:
+        # memory_write: process write lock + busy_timeout for SQLITE_BUSY safety.
+        with memory_write(MEMORY_DIR / "memory.db") as conn:
             conn.execute(
                 "INSERT INTO tool_events "
                 "(session_id, profile_id, project_path, tool_name, event_type, "
@@ -599,9 +588,6 @@ def log_tool_event_api(request: Request, data: dict):
                 (session_id, profile, project_path, tool_name, event_type,
                  input_summary, output_summary, now),
             )
-            conn.commit()
-        finally:
-            conn.close()
         return {"ok": True}
     except Exception:
         logger.exception("behavioral route error")

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 "

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

@@ -10,7 +10,6 @@ Uses V3 compliance modules: ABACEngine, AuditChain, RetentionEngine.
 """
 import json
 import logging
-import sqlite3
 from typing import Optional
 
 from fastapi import APIRouter, Query, Request
@@ -18,6 +17,7 @@ from fastapi.responses import JSONResponse
 
 from .helpers import get_active_profile, get_engine_lazy, MEMORY_DIR, DB_PATH
 from superlocalmemory.server.route_mutations import authorize_route_mutation
+from superlocalmemory.storage.memory_write import memory_write
 
 logger = logging.getLogger("superlocalmemory.routes.compliance")
 router = APIRouter()
@@ -61,13 +61,14 @@ async def compliance_status():
         except Exception as exc:
             logger.debug("audit chain: %s", exc)
 
-        # Retention policies (scoped to the active profile)
+        # Retention policies (scoped to the active profile).
+        # RetentionEngine.__init__ runs DDL (CREATE TABLE IF NOT EXISTS) so even
+        # list_rules() is a write at the constructor level — use memory_write().
         retention_policies = []
         try:
-            conn = sqlite3.connect(str(DB_PATH))
-            engine = RetentionEngine(conn)
-            retention_policies = engine.list_rules(profile)
-            conn.close()
+            with memory_write(DB_PATH) as conn:
+                engine = RetentionEngine(conn)
+                retention_policies = engine.list_rules(profile)
         except Exception as exc:
             logger.debug("retention engine: %s", exc)
 
@@ -163,15 +164,13 @@ async def create_retention_policy(data: dict):
 
     try:
         profile = get_active_profile()
-        conn = sqlite3.connect(str(DB_PATH))
-        engine = RetentionEngine(conn)
-
-        rule_id = engine.create_rule(
-            name=name, framework=framework,
-            retention_days=retention_days, action=action,
-            applies_to=applies_to, profile_id=profile,
-        )
-        conn.close()
+        with memory_write(DB_PATH) as conn:
+            engine = RetentionEngine(conn)
+            rule_id = engine.create_rule(
+                name=name, framework=framework,
+                retention_days=retention_days, action=action,
+                applies_to=applies_to, profile_id=profile,
+            )
 
         return {
             "success": True, "rule_id": rule_id,
@@ -190,10 +189,9 @@ async def delete_retention_policy(name: str = Query(...)):
         return {"success": False, "error": "Compliance engine not available"}
     try:
         profile = get_active_profile()
-        conn = sqlite3.connect(str(DB_PATH))
-        engine = RetentionEngine(conn)
-        removed = engine.delete_rule(profile, name)
-        conn.close()
+        with memory_write(DB_PATH) as conn:
+            engine = RetentionEngine(conn)
+            removed = engine.delete_rule(profile, name)
         if not removed:
             return {"success": False, "error": f"Policy '{name}' not found"}
         return {"success": True, "active_profile": profile,
@@ -214,10 +212,9 @@ async def enforce_retention():
         return {"success": False, "error": "Compliance engine not available"}
     try:
         profile = get_active_profile()
-        conn = sqlite3.connect(str(DB_PATH))
-        engine = RetentionEngine(conn)
-        result = engine.enforce(profile)
-        conn.close()
+        with memory_write(DB_PATH) as conn:
+            engine = RetentionEngine(conn)
+            result = engine.enforce(profile)
         return {"success": True, **result}
     except Exception:
         logger.exception("enforce_retention error")

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

@@ -436,3 +436,86 @@ def put_forgetting_config(request: Request, body: ForgettingConfigUpdate):
     except Exception:
         logger.exception("put_forgetting_config failed")
         return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# Graph Pruning config (v3.8.4-G — GitHub #84)
+# Dedicated endpoint so the forgetting config partial-update contract stays
+# clean.  Callers that only want graph knobs do not need to know about the
+# Ebbinghaus curve, and vice-versa.
+# ---------------------------------------------------------------------------
+
+_GRAPH_PRUNING_DEFAULTS: dict = {
+    "max_degree_per_node": 100,
+    "min_edge_weight": 0.0,
+    "enabled": True,
+}
+
+
+class GraphPruningConfigUpdate(BaseModel):
+    """Partial update model for graph pruning configuration.
+
+    All fields are optional so a PUT with only ``max_degree_per_node`` does
+    NOT reset ``min_edge_weight`` back to the default.  Existing values are
+    preserved; only the supplied fields are overwritten.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    max_degree_per_node: Optional[int] = Field(None, ge=1)
+    min_edge_weight: Optional[float] = Field(None, ge=0.0, le=1.0)
+    enabled: Optional[StrictBool] = None
+
+
+# ---------------------------------------------------------------------------
+# GET /api/v3/graph/config
+# ---------------------------------------------------------------------------
+
+
+@router.get("/graph/config")
+def get_graph_config():
+    """Return current graph thinning configuration.
+
+    Returns all three fields with their defaults when config.json has no
+    ``graph_pruning`` section (old installations).
+    """
+    try:
+        data = _read_config()
+        stored = data.get("graph_pruning", {})
+        result = {**_GRAPH_PRUNING_DEFAULTS, **stored}
+        # Return only known fields
+        return {k: result[k] for k in _GRAPH_PRUNING_DEFAULTS}
+    except Exception:
+        logger.exception("get_graph_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/v3/graph/config
+# ---------------------------------------------------------------------------
+
+
+@router.put("/graph/config")
+def put_graph_config(request: Request, body: GraphPruningConfigUpdate):
+    """Update graph thinning configuration.
+
+    Only supplied fields are written; all other graph pruning fields are
+    preserved.  Changes take effect at the next maintenance cycle without
+    requiring a daemon restart (the scheduler reads graph_pruning live from
+    the config object, which the daemon reloads from disk on each cycle).
+    """
+    _require_admin(request)
+    try:
+        updates = body.model_dump(exclude_none=True)
+
+        def mutate(data: dict) -> None:
+            stored = data.get("graph_pruning", {})
+            merged = {**_GRAPH_PRUNING_DEFAULTS, **stored, **updates}
+            data["graph_pruning"] = merged
+
+        data = _update_config(mutate)
+        merged = data["graph_pruning"]
+        return {k: merged[k] for k in _GRAPH_PRUNING_DEFAULTS}
+    except Exception:
+        logger.exception("put_graph_config failed")
+        return JSONResponse({"error": "Internal server error"}, status_code=500)

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

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter, HTTPException, Query, Request
 
-from .helpers import get_active_profile, require_engine
+from .helpers import get_active_profile, get_read_connection, require_engine
 
 router = APIRouter(prefix="/api/entity", tags=["entity"])
 
@@ -82,9 +82,7 @@ def list_entities(
     profile = profile or get_active_profile()
     _require_read(request, profile)
 
-    import sqlite3
-    conn = sqlite3.connect(str(engine._config.db_path))
-    conn.row_factory = sqlite3.Row
+    conn = get_read_connection(engine._config.db_path)
     try:
         where = ["ce.profile_id = ?"]
         params: list[object] = [profile]
@@ -158,9 +156,7 @@ def get_entity(
     _require_read(request, profile)
 
     import json
-    import sqlite3
-    conn = sqlite3.connect(str(engine._config.db_path))
-    conn.row_factory = sqlite3.Row
+    conn = get_read_connection(engine._config.db_path)
     try:
         # Search by canonical_name (case-insensitive)
         row = conn.execute("""

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

@@ -15,6 +15,7 @@ from fastapi import APIRouter, Request
 from pydantic import BaseModel
 
 from superlocalmemory.server.config_file import read_config, update_config
+from superlocalmemory.storage.read_connection import ReadConnectionFactory
 
 from .helpers import MEMORY_DIR, get_active_profile
 
@@ -261,12 +262,9 @@ def evolution_lineage(request: Request, skill_name: str = ""):
     _require_read(request)
     conn = None
     try:
-        import sqlite3 as _sqlite3
-
-        db_path = str(MEMORY_DIR / "memory.db")
+        db_path = MEMORY_DIR / "memory.db"
         profile_id = get_active_profile()
-        conn = _sqlite3.connect(db_path, timeout=10)
-        conn.row_factory = _sqlite3.Row
+        conn = ReadConnectionFactory(db_path).open()
 
         if skill_name:
             rows = conn.execute(

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

@@ -22,6 +22,7 @@ from fastapi import HTTPException, Request
 from pydantic import BaseModel, Field
 
 from superlocalmemory.infra.data_root import DynamicStatePath, canonical_data_root
+from superlocalmemory.storage.memory_write import memory_read, memory_write
 
 
 _engine_logger = logging.getLogger("superlocalmemory.engine")
@@ -216,14 +217,48 @@ def log_mode_change(
     )
 
 
-def get_db_connection() -> sqlite3.Connection:
-    """Get database connection."""
-    if not DB_PATH.exists():
+class _RouteReadConnection:
+    """Compatibility wrapper for legacy route callers that close manually.
+
+    New routes should prefer ``with memory_read(path)``.  A few shared route
+    callers still expect ``get_db_connection()`` to return a connection they
+    can close themselves, so this wrapper preserves that contract without
+    reopening canonical ``memory.db`` in writable mode.
+    """
+
+    def __init__(self, db_path: Path) -> None:
+        object.__setattr__(self, "_snapshot", memory_read(db_path))
+        object.__setattr__(self, "_connection", self._snapshot.__enter__())
+        object.__setattr__(self, "_closed", False)
+
+    def __getattr__(self, name: str):
+        return getattr(self._connection, name)
+
+    def __setattr__(self, name: str, value) -> None:
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._connection, name, value)
+
+    def close(self) -> None:
+        if not self._closed:
+            self._snapshot.__exit__(None, None, None)
+            object.__setattr__(self, "_closed", True)
+
+
+def get_read_connection(db_path: Path = DB_PATH) -> _RouteReadConnection:
+    """Return a legacy-compatible, physically read-only canonical connection."""
+    if not db_path.exists():
         raise HTTPException(
             status_code=500,
-            detail="Memory database not found. Run 'slm init' to initialize."
+            detail="Memory database not found. Run 'slm init' to initialize.",
         )
-    return sqlite3.connect(str(DB_PATH))
+    return _RouteReadConnection(db_path)
+
+
+def get_db_connection() -> _RouteReadConnection:
+    """Return the shared dashboard read connection for canonical ``memory.db``."""
+    return get_read_connection(DB_PATH)
 
 
 def dict_factory(cursor: sqlite3.Cursor, row: tuple) -> dict:
@@ -261,20 +296,22 @@ def validate_profile_name(name: str) -> bool:
 
 
 def ensure_profile_in_db(name: str, description: str = "") -> None:
-    """Ensure a profile row exists in SQLite (idempotent)."""
+    """Ensure a profile row exists in SQLite (idempotent).
+
+    Hot path: called on every authenticated request.  Uses ``memory_write()``
+    so in-process writers serialise through the write lock and cross-process
+    writers (hooks / CLI) wait via PRAGMA busy_timeout instead of getting
+    SQLITE_BUSY.
+    """
     if not DB_PATH.exists():
         return
-    conn = sqlite3.connect(str(DB_PATH))
-    try:
+    with memory_write(DB_PATH) as conn:
         conn.execute("PRAGMA foreign_keys=ON")
         conn.execute(
             "INSERT OR IGNORE INTO profiles (profile_id, name, description) "
             "VALUES (?, ?, ?)",
             (name, name, description or f"Memory profile: {name}"),
         )
-        conn.commit()
-    finally:
-        conn.close()
 
 
 def ensure_profile_in_json(name: str, description: str = "") -> None:
@@ -347,11 +384,12 @@ def delete_profile_from_db(name: str) -> None:
     rbac_memberships has no FK to profiles, so CASCADE does not remove role
     grants — they would otherwise survive deletion and silently re-activate if
     a profile of the same name is later recreated. Remove them explicitly.
+    Uses ``memory_write()`` so the multi-statement DELETE is atomic and
+    serialised against other in-process writers.
     """
     if not DB_PATH.exists():
         return
-    conn = sqlite3.connect(str(DB_PATH))
-    try:
+    with memory_write(DB_PATH) as conn:
         conn.execute("PRAGMA foreign_keys=ON")
         # Purge role grants for this workspace (no FK CASCADE covers these).
         for tbl in ("rbac_memberships",):
@@ -360,27 +398,21 @@ def delete_profile_from_db(name: str) -> None:
             except sqlite3.OperationalError:
                 pass  # table may not exist on older installs
         conn.execute("DELETE FROM profiles WHERE profile_id = ?", (name,))
-        conn.commit()
-    finally:
-        conn.close()
 
 
 def _get_db_profiles() -> list[dict]:
     """Read all profiles from SQLite."""
     if not DB_PATH.exists():
         return []
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
     try:
-        rows = conn.execute(
-            "SELECT profile_id, name, description, created_at, last_used "
-            "FROM profiles ORDER BY name"
-        ).fetchall()
-        return [dict(r) for r in rows]
+        with memory_read(DB_PATH) as conn:
+            rows = conn.execute(
+                "SELECT profile_id, name, description, created_at, last_used "
+                "FROM profiles ORDER BY name"
+            ).fetchall()
+            return [dict(r) for r in rows]
     except sqlite3.OperationalError:
         return []
-    finally:
-        conn.close()
 
 
 def _load_profiles_json() -> dict:

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

@@ -17,7 +17,7 @@ from typing import Any, Callable
 
 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__)
 
@@ -31,9 +31,7 @@ def _get_conn(profile: str = "") -> tuple[sqlite3.Connection | None, str]:
     pid = profile or get_active_profile()
     if not DB_PATH.exists():
         return None, pid
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    return conn, pid
+    return get_read_connection(DB_PATH), pid
 
 
 # ── Action Handlers ───────────────────────────────────────────────

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

@@ -12,7 +12,6 @@ Uses V3 learning modules: FeedbackCollector, EngagementTracker, AdaptiveLearner.
 import logging
 import shutil
 import sqlite3
-from contextlib import closing
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -30,6 +29,7 @@ from .learning_telemetry import (
 from .learning_telemetry import (
     sqlite_status as _sqlite_status,
 )
+from superlocalmemory.storage.memory_write import memory_read
 
 logger = logging.getLogger("superlocalmemory.routes.learning")
 router = APIRouter()
@@ -667,12 +667,9 @@ def get_patterns():
 
     # Graph intelligence contribution to learning (v3.4.1)
     try:
-        import sqlite3 as _sqlite3
-
         from superlocalmemory.server.routes.helpers import DB_PATH
         if DB_PATH.exists():
-            with closing(_sqlite3.connect(str(DB_PATH))) as conn:
-                conn.row_factory = _sqlite3.Row
+            with memory_read(DB_PATH) as conn:
                 row = conn.execute(
                     "SELECT COUNT(*) AS cnt, "
                     "COUNT(DISTINCT community_id) AS communities, "

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

@@ -7,13 +7,12 @@
 Routes: /api/lifecycle/status, /api/lifecycle/compact
 Uses V3 compliance.lifecycle.LifecycleManager.
 """
-import json
 import logging
 import sqlite3
 
 from fastapi import APIRouter, Request
 
-from .helpers import get_active_profile, get_engine_lazy, MEMORY_DIR, DB_PATH
+from .helpers import DB_PATH, get_active_profile, get_engine_lazy, get_read_connection
 from superlocalmemory.server.route_mutations import authorize_route_mutation
 
 logger = logging.getLogger("superlocalmemory.routes.lifecycle")
@@ -36,8 +35,7 @@ async def lifecycle_status():
 
     try:
         profile = get_active_profile()
-        conn = sqlite3.connect(str(DB_PATH))
-        conn.row_factory = sqlite3.Row
+        conn = get_read_connection(DB_PATH)
 
         # V3.3: Use fact_retention.lifecycle_zone (Ebbinghaus-driven, authoritative)
         # Falls back to atomic_facts.lifecycle for pre-3.3 databases