superlocalmemory 3.6.22 → 3.7.0

package/src/superlocalmemory/retrieval/semantic_channel.py

@@ -13,7 +13,7 @@ where all variances are identical, Fisher distance degenerates to a
 monotonic transform of Euclidean distance — same ranking as cosine.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations
@@ -34,6 +34,20 @@ logger = logging.getLogger(__name__)
 _VARIANCE_FLOOR: float = 1e-6
 
 
+class _LanceCandidateSource:
+    """Adapt the promoted Lance projection to the existing candidate contract."""
+
+    available = True
+
+    def __init__(self, backend: Any) -> None:
+        self._backend = backend
+
+    def search(self, query_embedding: list[float], *, top_k: int, profile_id: str) -> list[tuple[str, float]]:
+        return self._backend.similarity_search(
+            query_embedding, top_k=top_k, profile_id=profile_id,
+        )
+
+
 def _cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
     """Cosine similarity in [-1, 1]. Returns 0.0 on zero vectors."""
     norm_a = np.linalg.norm(a)
@@ -95,6 +109,9 @@ class SemanticChannel:
         # V3.3.26: Lazily instantiated FRQAD metric for mixed-precision scoring
         self._frqad_metric: object | None = None
         self._vector_store = vector_store
+        self._scale_vector_backend: Any | None = None
+        self._scale_shadow_checks = 0
+        self._scale_shadow_mismatches = 0
         # V3.3.19: TurboQuant 3-tier search (stateless, optional)
         self._qas = quantization_aware_search
 
@@ -123,6 +140,23 @@ class SemanticChannel:
 
         q_vec = np.array(query_embedding, dtype=np.float32)
 
+        # Lance is a derived projection.  It is never an authorization source
+        # and it never silently replaces the canonical sqlite-vec path: every
+        # promoted query is shadowed and falls back if membership/order differs.
+        if (
+            self._scale_vector_backend is not None
+            and not bool(getattr(self, "include_global", False))
+            and not bool(getattr(self, "include_shared", False))
+        ):
+            projected = self._search_via_lance(query_embedding, q_vec, profile_id, top_k)
+            canonical = self._search_without_lance(query_embedding, q_vec, profile_id, top_k)
+            self._scale_shadow_checks += 1
+            if [fid for fid, _ in projected] == [fid for fid, _ in canonical]:
+                return projected
+            self._scale_shadow_mismatches += 1
+            logger.warning("Lance semantic projection diverged from SQLite; using SQLite")
+            return canonical
+
         # --- FAST PATH: sqlite-vec KNN ---
         if self._vector_store and self._vector_store.available:
             results = self._search_via_vector_store(
@@ -135,6 +169,44 @@ class SemanticChannel:
         # --- FALLBACK: full-table scan (original code, unchanged) ---
         return self._search_full_scan(query_embedding, q_vec, profile_id, top_k)
 
+    def set_scale_vector_backend(self, backend: Any | None) -> None:
+        """Attach a parity-verified Lance projection without replacing SQLite."""
+        self._scale_vector_backend = backend
+
+    def scale_projection_telemetry(self) -> dict[str, int]:
+        return {
+            "shadow_checks": self._scale_shadow_checks,
+            "shadow_mismatches": self._scale_shadow_mismatches,
+        }
+
+    def _search_via_lance(
+        self, query_embedding: list[float], q_vec: np.ndarray, profile_id: str, top_k: int,
+    ) -> list[tuple[str, float]]:
+        original_store, original_qas = self._vector_store, self._qas
+        try:
+            self._vector_store = _LanceCandidateSource(self._scale_vector_backend)
+            # QAS indexes SQLite/quantized records and cannot represent Lance.
+            self._qas = None
+            return self._search_via_vector_store(query_embedding, q_vec, profile_id, top_k)
+        except Exception as exc:
+            logger.warning("Lance semantic projection failed closed to SQLite: %s", exc)
+            return []
+        finally:
+            self._vector_store, self._qas = original_store, original_qas
+
+    def _search_without_lance(
+        self, query_embedding: list[float], q_vec: np.ndarray, profile_id: str, top_k: int,
+    ) -> list[tuple[str, float]]:
+        backend, self._scale_vector_backend = self._scale_vector_backend, None
+        try:
+            if self._vector_store and self._vector_store.available:
+                results = self._search_via_vector_store(query_embedding, q_vec, profile_id, top_k)
+                if results:
+                    return results
+            return self._search_full_scan(query_embedding, q_vec, profile_id, top_k)
+        finally:
+            self._scale_vector_backend = backend
+
     def _search_via_vector_store(
         self,
         query_embedding: list[float],
@@ -162,6 +234,36 @@ class SemanticChannel:
             knn_results = self._vector_store.search(
                 query_embedding, top_k=top_k * 2, profile_id=profile_id,
             )
+
+        # The vector index is partitioned by owner profile. An opted-in global
+        # or authorized shared fact owned by another profile cannot enter the
+        # local KNN candidate set, so merge the bounded cross-profile visible
+        # supplement using the same canonical DB scope predicate as fallback.
+        include_global = bool(getattr(self, "include_global", False))
+        include_shared = bool(getattr(self, "include_shared", False))
+        external_facts = self._db.get_external_visible_facts(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
+        external_scores: list[tuple[str, float]] = []
+        for fact in external_facts:
+            if fact.embedding is None:
+                continue
+            fact_vec = np.array(fact.embedding, dtype=np.float32)
+            if fact_vec.shape != q_vec.shape:
+                continue
+            score = (_cosine_similarity(q_vec, fact_vec) + 1.0) / 2.0
+            if score > 0.05:
+                external_scores.append((fact.fact_id, score))
+
+        if external_scores:
+            combined = {fid: score for fid, score in knn_results}
+            for fact_id, score in external_scores:
+                combined[fact_id] = max(combined.get(fact_id, 0.0), score)
+            knn_results = sorted(
+                combined.items(), key=lambda item: item[1], reverse=True,
+            )[:top_k * 2]
         if not knn_results:
             return []  # Caller falls through to full scan
 
@@ -175,7 +277,12 @@ class SemanticChannel:
         )
 
         if not facts:
-            return [(fid, score) for fid, score in knn_results[:top_k]]
+            # The vector/QAS indexes are candidate sources, never an
+            # authorization source.  Returning their raw IDs here leaked an
+            # owner-private fact precisely when canonical scope filtering
+            # rejected the entire candidate set.  Empty means "no authorized
+            # fast-path hits" so the caller may use the scoped full scan.
+            return []
 
         # Step 3: Fisher-Rao re-scoring on the subset
         q_mean: np.ndarray | None = None
@@ -189,12 +296,7 @@ class SemanticChannel:
         for fact in facts:
             cos_sim = knn_scores.get(fact.fact_id, 0.0)
 
-            # V3.3.21: Fisher-Rao ramp with minimum floor.
-            # Bug fix: access_count=0 for fresh facts → Fisher weight=0 → metric DEAD.
-            # Paper 2's +12pp on multi-hop came from Fisher-Rao. A 0.3 floor ensures
-            # fresh facts still benefit from variance-weighted similarity, while
-            # frequently accessed facts get progressively stronger Fisher influence.
-            fisher_weight = max(0.15, min(1.2, (fact.access_count or 0) / 10.0 * 1.2))
+            fisher_weight = self._fisher_weight(fact.access_count)
 
             if (fisher_weight > 0.01
                     and fact.fisher_variance is not None
@@ -205,8 +307,7 @@ class SemanticChannel:
                 f_sim = self._compute_fisher_sim(
                     q_vec, f_vec, var_vec, fact, q_mean, q_var,
                 )
-                capped_w = min(1.0, fisher_weight)
-                sim = capped_w * f_sim + (1.0 - capped_w) * cos_sim
+                sim = fisher_weight * f_sim + (1.0 - fisher_weight) * cos_sim
             else:
                 sim = cos_sim
 
@@ -252,8 +353,8 @@ class SemanticChannel:
             # Cosine baseline (always computed)
             cos_sim = (_cosine_similarity(q_vec, f_vec) + 1.0) / 2.0
 
-            # Graduated Fisher-Rao ramp (F37, F108)
-            fisher_weight = min(1.2, (fact.access_count or 0) / 10.0 * 1.2)
+            # The weighting contract is identical to the sqlite-vec path.
+            fisher_weight = self._fisher_weight(fact.access_count)
 
             if (fisher_weight > 0.01
                     and fact.fisher_variance is not None
@@ -262,8 +363,7 @@ class SemanticChannel:
                 f_sim = self._compute_fisher_sim(
                     q_vec, f_vec, var_vec, fact, q_mean, q_var,
                 )
-                capped_w = min(1.0, fisher_weight)
-                sim = capped_w * f_sim + (1.0 - capped_w) * cos_sim
+                sim = fisher_weight * f_sim + (1.0 - fisher_weight) * cos_sim
             else:
                 sim = cos_sim
 
@@ -273,6 +373,14 @@ class SemanticChannel:
         scored.sort(key=lambda x: x[1], reverse=True)
         return scored[:top_k]
 
+    @staticmethod
+    def _fisher_weight(access_count: int | None) -> float:
+        """Canonical Fisher blend shared by every semantic candidate path."""
+        graduated = (access_count or 0) / 10.0 * 1.2
+        # A small floor keeps Fisher variance active for new facts.  The cap
+        # prevents the blend from extrapolating beyond its two score inputs.
+        return min(1.0, max(0.15, graduated))
+
     # ------------------------------------------------------------------
     # Fisher similarity dispatch
     # ------------------------------------------------------------------

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -12,7 +12,7 @@ Reads BOTH graph_edges + association_edges via UNION query (Rule 13).
 Registered as 5th channel via ChannelRegistry (needs_embedding=True).
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations
@@ -25,6 +25,11 @@ from typing import Any
 
 import numpy as np
 
+from superlocalmemory.retrieval.scope_policy import (
+    authorized_fact_ids,
+    filter_authorized_results,
+)
+from superlocalmemory.storage.database import _scope_where
 from superlocalmemory.storage.models import _new_id
 
 logger = logging.getLogger(__name__)
@@ -113,22 +118,77 @@ class SpreadingActivation:
         if not self._config.enabled:
             return []
 
+        include_global = bool(getattr(self, "include_global", False))
+        include_shared = bool(getattr(self, "include_shared", False))
         try:
             # Step 0: Get seed nodes from VectorStore KNN
             seed_results = self._vector_store.search(
                 query, top_k=self._config.top_m, profile_id=profile_id,
             )
+            # Owner-partitioned vector indexes cannot discover opted-in peers.
+            # Add visible external embeddings with the same cosine seed signal.
+            try:
+                external_facts = self._db.get_external_visible_facts(
+                    profile_id,
+                    include_global=include_global,
+                    include_shared=include_shared,
+                )
+            except Exception:
+                external_facts = []
+            q_vec = np.array(query, dtype=np.float32)
+            q_norm = float(np.linalg.norm(q_vec))
+            combined = {fact_id: score for fact_id, score in seed_results}
+            for fact in external_facts:
+                embedding = getattr(fact, "embedding", None)
+                if embedding is None:
+                    continue
+                fact_vec = np.array(embedding, dtype=np.float32)
+                if fact_vec.shape != q_vec.shape:
+                    continue
+                denominator = q_norm * float(np.linalg.norm(fact_vec))
+                if denominator <= 1e-8:
+                    continue
+                score = (float(np.dot(q_vec, fact_vec) / denominator) + 1.0) / 2.0
+                combined[fact.fact_id] = max(combined.get(fact.fact_id, 0.0), score)
+            allowed_seeds = authorized_fact_ids(
+                self._db,
+                combined,
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+            )
+            seed_results = [
+                (fact_id, score)
+                for fact_id, score in combined.items()
+                if fact_id in allowed_seeds
+            ]
             if not seed_results:
                 return []
 
             # Check cache first
-            query_hash = self._compute_query_hash(query, profile_id)
+            query_hash = self._compute_query_hash(
+                query,
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+            )
             cached = self._get_cached_results(query_hash, profile_id)
             if cached:
-                return cached[:top_k]
+                return filter_authorized_results(
+                    self._db,
+                    cached,
+                    profile_id,
+                    include_global=include_global,
+                    include_shared=include_shared,
+                )[:top_k]
 
             # Run 5-step spreading activation
-            activations = self._propagate(seed_results, profile_id)
+            activations = self._propagate(
+                seed_results,
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+            )
 
             # FOK gating
             if not self._fok_check(activations):
@@ -141,7 +201,13 @@ class SpreadingActivation:
             results = sorted(
                 activations.items(), key=lambda x: x[1], reverse=True,
             )
-            return results[:top_k]
+            return filter_authorized_results(
+                self._db,
+                results,
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+            )[:top_k]
 
         except Exception as exc:
             logger.warning(
@@ -154,6 +220,9 @@ class SpreadingActivation:
         self,
         seeds: list[tuple[str, float]],
         profile_id: str,
+        *,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> dict[str, float]:
         """Execute the 5-step SYNAPSE algorithm.
 
@@ -186,7 +255,22 @@ class SpreadingActivation:
 
                 # Get neighbors from BOTH tables (Rule 13) — cached per node
                 if node_id not in neighbor_cache:
-                    neighbor_cache[node_id] = self._get_unified_neighbors(node_id, profile_id)
+                    raw_neighbors = self._get_unified_neighbors(
+                        node_id,
+                        profile_id,
+                        include_global=include_global,
+                        include_shared=include_shared,
+                    )
+                    allowed_neighbors = authorized_fact_ids(
+                        self._db,
+                        (neighbor_id for neighbor_id, _weight in raw_neighbors),
+                        profile_id,
+                        include_global=include_global,
+                        include_shared=include_shared,
+                    )
+                    neighbor_cache[node_id] = [
+                        item for item in raw_neighbors if item[0] in allowed_neighbors
+                    ]
                 neighbors = neighbor_cache[node_id]
 
                 # Out-degree for fan effect normalization
@@ -226,7 +310,12 @@ class SpreadingActivation:
         return activations
 
     def _get_unified_neighbors(
-        self, node_id: str, profile_id: str,
+        self,
+        node_id: str,
+        profile_id: str,
+        *,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> list[tuple[str, float]]:
         """Get neighbors from BOTH graph_edges and association_edges.
 
@@ -245,41 +334,56 @@ class SpreadingActivation:
             # all 2.1M edges then sorting. Each branch wrapped in SELECT * FROM (...)
             # because SQLite requires parentheses for ORDER BY+LIMIT in compound SELECTs.
             lim = self._config.max_neighbors_per_node
+            graph_where, graph_params = _scope_where(
+                profile_id,
+                include_global=include_global,
+                include_shared=include_shared,
+                prefix="ge",
+            )
+            # association_edges has no scope/shared_with columns in the current
+            # schema, so it remains owner-profile-only. Endpoint authorization
+            # below still prevents a private candidate from entering results.
+            assoc_where = "ae.profile_id = ?"
+            assoc_params = [profile_id]
             rows = self._db.execute(
-                """
+                f"""
                 SELECT neighbor_id, weight FROM (
                     SELECT * FROM (
-                        SELECT target_id AS neighbor_id, weight FROM graph_edges
-                        WHERE source_id = ? AND profile_id = ?
+                        SELECT target_id AS neighbor_id, weight FROM graph_edges AS ge
+                        WHERE source_id = ? AND {graph_where}
                         ORDER BY weight DESC LIMIT ?
                     )
                     UNION ALL
                     SELECT * FROM (
-                        SELECT target_fact_id AS neighbor_id, weight FROM association_edges
-                        WHERE source_fact_id = ? AND profile_id = ?
+                        SELECT target_fact_id AS neighbor_id, weight
+                        FROM association_edges AS ae
+                        WHERE source_fact_id = ? AND {assoc_where}
                         ORDER BY weight DESC LIMIT ?
                     )
                     UNION ALL
                     SELECT * FROM (
-                        SELECT source_id AS neighbor_id, weight FROM graph_edges
-                        WHERE target_id = ? AND profile_id = ?
+                        SELECT source_id AS neighbor_id, weight FROM graph_edges AS ge
+                        WHERE target_id = ? AND {graph_where}
                         ORDER BY weight DESC LIMIT ?
                     )
                     UNION ALL
                     SELECT * FROM (
-                        SELECT source_fact_id AS neighbor_id, weight FROM association_edges
-                        WHERE target_fact_id = ? AND profile_id = ?
+                        SELECT source_fact_id AS neighbor_id, weight
+                        FROM association_edges AS ae
+                        WHERE target_fact_id = ? AND {assoc_where}
                         ORDER BY weight DESC LIMIT ?
                     )
                 )
                 ORDER BY weight DESC
                 LIMIT ?
                 """,
-                (node_id, profile_id, lim,
-                 node_id, profile_id, lim,
-                 node_id, profile_id, lim,
-                 node_id, profile_id, lim,
-                 lim),
+                (
+                    node_id, *graph_params, lim,
+                    node_id, *assoc_params, lim,
+                    node_id, *graph_params, lim,
+                    node_id, *assoc_params, lim,
+                    lim,
+                ),
             )
             return [
                 (dict(r)["neighbor_id"], dict(r)["weight"]) for r in rows
@@ -301,14 +405,26 @@ class SpreadingActivation:
             return False
         return max(activations.values()) >= self._config.tau_gate
 
-    def _compute_query_hash(self, query: Any, profile_id: str) -> str:
+    def _compute_query_hash(
+        self,
+        query: Any,
+        profile_id: str,
+        *,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> str:
         """Deterministic hash for cache key."""
+        scope_bytes = f"|g={int(include_global)}|s={int(include_shared)}".encode()
         if isinstance(query, np.ndarray):
-            data = query.tobytes() + profile_id.encode()
+            data = query.tobytes() + profile_id.encode() + scope_bytes
         elif isinstance(query, list):
-            data = np.array(query, dtype=np.float32).tobytes() + profile_id.encode()
+            data = (
+                np.array(query, dtype=np.float32).tobytes()
+                + profile_id.encode()
+                + scope_bytes
+            )
         else:
-            data = str(query).encode() + profile_id.encode()
+            data = str(query).encode() + profile_id.encode() + scope_bytes
         return hashlib.sha256(data).hexdigest()[:16]
 
     def _get_cached_results(

package/src/superlocalmemory/retrieval/strategy.py

@@ -8,7 +8,7 @@ Classifies query type and returns per-type channel weights.
 V1 had this code (strategy_learner.py) but never wired it in.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 from __future__ import annotations
 

package/src/superlocalmemory/retrieval/temporal_channel.py

@@ -8,7 +8,7 @@ Searches by referenced_date (NOT just created_at like V1).
 Returns empty when query has no temporal signal (no recency noise).
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 from __future__ import annotations
 
@@ -17,9 +17,10 @@ import math
 from datetime import datetime
 from typing import TYPE_CHECKING
 
-from dateutil.parser import parse as dateutil_parse, ParserError
+from dateutil.parser import ParserError, parse as dateutil_parse
 
 from superlocalmemory.encoding.temporal_parser import TemporalParser
+from superlocalmemory.storage.database import _scope_where
 
 if TYPE_CHECKING:
     from superlocalmemory.storage.database import DatabaseManager
@@ -148,18 +149,24 @@ class TemporalChannel:
 
         results: list[tuple[str, float]] = []
         seen: set[str] = set()
+        where, params = _scope_where(
+            profile_id,
+            include_global=bool(getattr(self, "include_global", False)),
+            include_shared=bool(getattr(self, "include_shared", False)),
+            prefix="af",
+        )
 
         for name in names[:3]:  # Limit to first 3 entity mentions
-            # Look up entity ID
-            entity = self._db.get_entity_by_name(name, profile_id)
-            if entity is None:
-                continue
-
-            # Find all temporal events for this entity
+            # Resolve the entity and event in one scope-filtered query. Looking
+            # up the entity only in the requester's profile made global events
+            # owned by another profile undiscoverable before authorization was
+            # even evaluated.
             rows = self._db.execute(
-                "SELECT fact_id FROM temporal_events "
-                "WHERE profile_id = ? AND entity_id = ?",
-                (profile_id, entity.entity_id),
+                "SELECT te.fact_id FROM temporal_events AS te "
+                "JOIN canonical_entities AS ce ON ce.entity_id = te.entity_id "
+                "JOIN atomic_facts AS af ON af.fact_id = te.fact_id "
+                f"WHERE {where} AND LOWER(ce.canonical_name) = LOWER(?)",
+                (*params, name),
             )
             for row in rows:
                 fid = dict(row)["fact_id"]
@@ -173,11 +180,19 @@ class TemporalChannel:
         return results
 
     def _load_events(self, profile_id: str) -> list[dict]:
+        where, params = _scope_where(
+            profile_id,
+            include_global=bool(getattr(self, "include_global", False)),
+            include_shared=bool(getattr(self, "include_shared", False)),
+            prefix="af",
+        )
         rows = self._db.execute(
-            "SELECT fact_id, observation_date, referenced_date, "
-            "interval_start, interval_end "
-            "FROM temporal_events WHERE profile_id = ?",
-            (profile_id,),
+            "SELECT te.fact_id, te.observation_date, te.referenced_date, "
+            "te.interval_start, te.interval_end "
+            "FROM temporal_events AS te "
+            "JOIN atomic_facts AS af ON af.fact_id = te.fact_id "
+            f"WHERE {where}",
+            (*params,),
         )
         return [dict(r) for r in rows]
 

package/src/superlocalmemory/retrieval/vector_store.py

@@ -9,7 +9,7 @@ Falls back to ANNIndex if sqlite-vec is unavailable (Rule 03).
 Implements ANNSearchable protocol for GraphBuilder compatibility (Rule 07).
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations

package/src/superlocalmemory/server/api.py

@@ -24,12 +24,13 @@ import uvicorn
 
 from superlocalmemory.server.security_middleware import SecurityHeadersMiddleware
 from superlocalmemory.server.routes.helpers import SLM_VERSION
+from superlocalmemory.infra.data_root import DynamicStatePath
 
 logger = logging.getLogger("superlocalmemory.api_server")
 
 # V3 paths
-MEMORY_DIR = Path.home() / ".superlocalmemory"
-DB_PATH = MEMORY_DIR / "memory.db"
+MEMORY_DIR = DynamicStatePath()
+DB_PATH = DynamicStatePath("memory.db")
 # V3.3.21: UI shipped inside the package for pip/npm installs.
 _PKG_UI = Path(__file__).resolve().parent.parent / "ui"
 _REPO_UI = Path(__file__).resolve().parent.parent.parent.parent / "ui"
@@ -75,6 +76,12 @@ async def lifespan(application: FastAPI):
         application.state.engine = None
         application.state.config = None
 
+    # Event fan-out belongs to the same application lifecycle as the engine.
+    # Registering it through FastAPI.on_event created a second, deprecated
+    # startup path and made TestClient initialization emit warnings.
+    from superlocalmemory.server.routes.events import register_event_listener
+
+    register_event_listener()
     yield
 
     # Cleanup
@@ -169,7 +176,7 @@ def create_app() -> FastAPI:
     from superlocalmemory.server.routes.profiles import router as profiles_router
     from superlocalmemory.server.routes.backup import router as backup_router
     from superlocalmemory.server.routes.data_io import router as data_io_router
-    from superlocalmemory.server.routes.events import router as events_router, register_event_listener
+    from superlocalmemory.server.routes.events import router as events_router
     from superlocalmemory.server.routes.agents import router as agents_router
     from superlocalmemory.server.routes.ws import router as ws_router, manager as ws_manager
     from superlocalmemory.server.routes.v3_api import router as v3_router
@@ -237,10 +244,6 @@ def create_app() -> FastAPI:
             "timestamp": datetime.now(timezone.utc).isoformat(),
         }
 
-    @application.on_event("startup")
-    async def startup_event():
-        register_event_listener()
-
     return application
 
 

package/src/superlocalmemory/server/bandit_loops.py

@@ -24,6 +24,8 @@ import os
 from pathlib import Path
 from typing import Any
 
+from superlocalmemory.infra.data_root import state_path
+
 logger = logging.getLogger(__name__)
 
 _REWARD_INTERVAL = float(
@@ -42,7 +44,7 @@ def _learning_db(config: Any) -> Path:
         cand = getattr(config, "learning_db_path", None)
         if cand is not None:
             return Path(cand)
-    return Path.home() / ".superlocalmemory" / "learning.db"
+    return state_path("learning.db")
 
 
 def _memory_db(config: Any) -> Path:
@@ -50,7 +52,7 @@ def _memory_db(config: Any) -> Path:
         cand = getattr(config, "db_path", None)
         if cand is not None:
             return Path(cand)
-    return Path.home() / ".superlocalmemory" / "memory.db"
+    return state_path("memory.db")
 
 
 def _profile_id(config: Any) -> str: