superlocalmemory 3.7.8 → 3.8.1

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

@@ -0,0 +1,153 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+"""Read-only persisted telemetry used by the Living Brain routes."""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from pathlib import Path
+
+logger = logging.getLogger("superlocalmemory.routes.learning")
+
+SOURCE_SCORE_LIMIT = 50
+
+
+class ReadOnlyRankerStore:
+    """Minimal model-cache adapter that never creates or migrates tables."""
+
+    def __init__(self, db_path: Path) -> None:
+        self._db_path = Path(db_path)
+
+    def count_signals(self, profile_id: str) -> int:
+        connection = _readonly_connection(self._db_path)
+        try:
+            row = connection.execute(
+                "SELECT COUNT(*) AS count FROM learning_signals "
+                "WHERE profile_id = ?",
+                (profile_id,),
+            ).fetchone()
+            return int(row["count"] if row else 0)
+        finally:
+            connection.close()
+
+    def load_active_model(self, profile_id: str) -> dict | None:
+        connection = _readonly_connection(self._db_path)
+        try:
+            row = connection.execute(
+                "SELECT state_bytes, bytes_sha256, feature_names, trained_at, "
+                "model_version FROM learning_model_state "
+                "WHERE profile_id = ? AND is_active = 1 LIMIT 1",
+                (profile_id,),
+            ).fetchone()
+        finally:
+            connection.close()
+        if row is None:
+            return None
+        return {
+            "state_bytes": bytes(row["state_bytes"]),
+            "bytes_sha256": row["bytes_sha256"],
+            "feature_names": row["feature_names"],
+            "trained_at": row["trained_at"],
+            "model_version": row["model_version"],
+        }
+
+
+def _readonly_connection(db_path: Path) -> sqlite3.Connection:
+    connection = sqlite3.connect(
+        f"file:{db_path}?mode=ro", uri=True, timeout=1.0,
+    )
+    connection.execute("PRAGMA busy_timeout=1000")
+    connection.row_factory = sqlite3.Row
+    return connection
+
+
+def sqlite_status(exc: sqlite3.Error) -> str:
+    """Return a stable, non-sensitive dashboard status for SQLite failures."""
+    message = str(exc).lower()
+    return (
+        "database_busy"
+        if "locked" in message or "busy" in message
+        else "query_error"
+    )
+
+
+def _table_exists(connection: sqlite3.Connection, table: str) -> bool:
+    row = connection.execute(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
+        (table,),
+    ).fetchone()
+    return row is not None
+
+
+def load_source_quality_state(profile_id: str, db_path: Path) -> dict:
+    """Read bounded source scores plus the profile's full source count."""
+    if not db_path.exists():
+        return {
+            "scores": {}, "tracked_sources": 0,
+            "status": "missing_database",
+        }
+    try:
+        connection = _readonly_connection(db_path)
+        try:
+            if not _table_exists(connection, "source_quality"):
+                return {
+                    "scores": {}, "tracked_sources": 0,
+                    "status": "missing_table",
+                }
+            count_row = connection.execute(
+                "SELECT COUNT(DISTINCT source_id) AS count "
+                "FROM source_quality WHERE profile_id = ? "
+                "AND source_id IS NOT NULL AND source_id != ''",
+                (profile_id,),
+            ).fetchone()
+            rows = connection.execute(
+                "SELECT source_id, alpha, beta FROM source_quality "
+                "WHERE profile_id = ? "
+                "ORDER BY updated_at DESC LIMIT ?",
+                (profile_id, SOURCE_SCORE_LIMIT),
+            ).fetchall()
+        finally:
+            connection.close()
+    except sqlite3.Error as exc:
+        status = sqlite_status(exc)
+        logger.warning("source quality telemetry %s: %s", status, exc)
+        return {"scores": {}, "tracked_sources": 0, "status": status}
+
+    scores: dict[str, float] = {}
+    for row in rows:
+        alpha, beta = float(row["alpha"] or 0), float(row["beta"] or 0)
+        source_id = str(row["source_id"] or "")
+        if alpha + beta > 0 and source_id and source_id not in scores:
+            scores[source_id] = round(alpha / (alpha + beta), 4)
+    return {
+        "scores": scores,
+        "tracked_sources": int(count_row["count"] if count_row else 0),
+        "status": "available",
+    }
+
+
+def load_model_state(profile_id: str, db_path: Path) -> dict:
+    """Count persisted model artifacts without inferring them from signals."""
+    if not db_path.exists():
+        return {"models_trained": 0, "status": "missing_database"}
+    try:
+        connection = _readonly_connection(db_path)
+        try:
+            if not _table_exists(connection, "learning_model_state"):
+                return {"models_trained": 0, "status": "missing_table"}
+            row = connection.execute(
+                "SELECT COUNT(*) AS count FROM learning_model_state "
+                "WHERE profile_id = ?",
+                (profile_id,),
+            ).fetchone()
+        finally:
+            connection.close()
+    except sqlite3.Error as exc:
+        status = sqlite_status(exc)
+        logger.warning("model-state telemetry %s: %s", status, exc)
+        return {"models_trained": 0, "status": status}
+    return {
+        "models_trained": int(row["count"] if row else 0),
+        "status": "available",
+    }

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

@@ -11,9 +11,10 @@ import json
 import logging
 import sqlite3
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
-from .helpers import get_active_profile, MEMORY_DIR, DB_PATH
+from .helpers import get_active_profile, get_engine_lazy, MEMORY_DIR, DB_PATH
+from superlocalmemory.server.route_mutations import authorize_route_mutation
 
 logger = logging.getLogger("superlocalmemory.routes.lifecycle")
 router = APIRouter()
@@ -121,15 +122,65 @@ async def lifecycle_status():
             "recent_transitions": [],
             "age_stats": age_stats,
         }
-    except Exception as e:
-        logger.error("lifecycle_status error: %s", e)
-        return {"available": False, "error": str(e)}
+    except Exception:
+        logger.exception("lifecycle_status error")
+        return {"available": False, "error": "Internal server error"}
 
 
 @router.post("/api/lifecycle/compact")
-async def trigger_compaction(data: dict = {}):
-    """Trigger lifecycle compaction. Body: {dry_run: true/false}."""
+async def trigger_compaction(request: Request, data: dict = {}):
+    """Trigger lifecycle compaction for the active profile.
+
+    Body: ``{"dry_run": true|false}`` (default true — preview only).
+
+    Recomputes each fact's lifecycle zone (active→warm→cold→archive) from its
+    age/access pattern. dry_run returns the proposed transitions without
+    mutating; execute applies them and is profile-scoped + mutation-authorized.
+    """
     if not LIFECYCLE_AVAILABLE:
         return {"success": False, "error": "Lifecycle engine not available"}
 
-    return {"status": "not_implemented", "message": "Coming soon"}
+    dry_run = bool((data or {}).get("dry_run", True))
+    try:
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            return {"success": False, "error": "Engine not initialized"}
+        profile = get_active_profile()
+
+        mgr = LifecycleManager(engine._db)
+        facts = engine._db.get_all_facts(profile)
+        candidates = []
+        for f in facts:
+            new_state = mgr.get_lifecycle_state(f)
+            if new_state != f.lifecycle:
+                candidates.append({
+                    "fact_id": f.fact_id,
+                    "current": getattr(f.lifecycle, "value", str(f.lifecycle)),
+                    "proposed": getattr(new_state, "value", str(new_state)),
+                })
+
+        applied = 0
+        if not dry_run and candidates:
+            authorization = authorize_route_mutation(
+                request,
+                operation="update",
+                source_agent_id="http-lifecycle-compact",
+                profile_id=profile,
+            )
+            for c in candidates:
+                engine._db.update_fact(c["fact_id"], {"lifecycle": c["proposed"]})
+                applied += 1
+            authorization.complete()
+
+        return {
+            "success": True,
+            "dry_run": dry_run,
+            "active_profile": profile,
+            "total_facts": len(facts),
+            "candidates": len(candidates),
+            "applied": applied,
+            "transitions": candidates[:20],
+        }
+    except Exception as exc:
+        logger.exception("lifecycle compaction failed")
+        return {"success": False, "error": "internal error"}

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

@@ -20,6 +20,18 @@ logger = logging.getLogger("superlocalmemory.routes.memories")
 router = APIRouter()
 
 
+def _internal_error(detail: str = "Internal server error") -> HTTPException:
+    """SEC-H-02: log the full traceback server-side; return a generic message.
+
+    Returning ``str(e)`` to HTTP clients leaks DB schema (column/constraint
+    names), the data-directory filesystem path, and possibly config internals —
+    a GDPR Art. 32 gap. Call this only from inside an ``except`` block so
+    ``logger.exception`` captures the active traceback automatically.
+    """
+    logger.exception("memories route error")
+    return HTTPException(status_code=500, detail=detail)
+
+
 def _get_engine(request: Request):
     """Get V3 engine from app state, initializing lazily on first call."""
     return get_engine_lazy(request.app.state)
@@ -41,6 +53,15 @@ def _authorize_memory_mutation(
         getattr(request.app.state, "daemon_descriptor", None),
         actor_kind="dashboard",
     )
+    # RBAC (C3): on top of machine auth, enforce the caller's role on the active
+    # profile. delete → DELETE; every other mutation → WRITE. A viewer (or an
+    # owner in require_login mode) is rejected here; owner/admin/member pass.
+    from superlocalmemory.access.rbac import Permission as _Perm
+    from superlocalmemory.server.rbac_enforce import require_permission as _rbac_require
+    _rbac_require(
+        request,
+        _Perm.DELETE if operation == "delete" else _Perm.WRITE,
+    )
     engine = _get_engine(request)
     if engine is None:
         raise HTTPException(503, detail="Engine not initialized")
@@ -253,6 +274,14 @@ async def get_memories(
         None,
         description="Named filter: 'high_reward' | 'being_forgotten'",
     ),
+    scope: Optional[str] = Query(
+        None,
+        description=(
+            "Scope view (v3 only): 'shared' (shared with this profile), "
+            "'global' (global memories), 'all' (this profile + global + shared). "
+            "Default None = this profile only (unchanged isolation)."
+        ),
+    ),
 ):
     """List memories with optional filtering and pagination.
 
@@ -274,15 +303,36 @@ async def get_memories(
         use_v3 = _has_table(cursor, 'atomic_facts')
 
         if use_v3:
-            query = """
-                SELECT fact_id as id, memory_id, content, fact_type as category,
-                       confidence as importance, access_count,
-                       created_at, created_at as updated_at,
-                       session_id as project_name
-                FROM atomic_facts WHERE profile_id = ?
-            """
-            params = [active_profile]
-            count_base = "SELECT COUNT(*) as total FROM atomic_facts WHERE profile_id = ?"
+            # Scope view clause. Default (scope=None) is this-profile-only —
+            # identical isolation to before. Other values widen the view to
+            # global and/or shared-with-this-profile memories.
+            _esc = active_profile.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            _shared_pat = f'%"{_esc}"%'
+            if scope == "global":
+                scope_where = "scope = 'global'"
+                scope_params = []
+            elif scope == "shared":
+                scope_where = "scope = 'shared' AND shared_with LIKE ? ESCAPE '\\'"
+                scope_params = [_shared_pat]
+            elif scope == "all":
+                scope_where = (
+                    "(profile_id = ? OR scope = 'global' "
+                    "OR (scope = 'shared' AND shared_with LIKE ? ESCAPE '\\'))"
+                )
+                scope_params = [active_profile, _shared_pat]
+            else:
+                scope_where = "profile_id = ?"
+                scope_params = [active_profile]
+
+            query = (
+                "SELECT fact_id as id, memory_id, content, fact_type as category, "
+                "confidence as importance, access_count, "
+                "created_at, created_at as updated_at, "
+                "session_id as project_name, scope, shared_with "
+                f"FROM atomic_facts WHERE {scope_where}"
+            )
+            params = list(scope_params)
+            count_base = f"SELECT COUNT(*) as total FROM atomic_facts WHERE {scope_where}"
         else:
             query = """
                 SELECT id, content, summary, category, project_name, project_path,
@@ -293,7 +343,8 @@ async def get_memories(
             params = [active_profile]
             count_base = "SELECT COUNT(*) as total FROM memories WHERE profile = ?"
 
-        count_params = [active_profile]
+        # count params must mirror the base WHERE params (scope-aware for v3).
+        count_params = list(params)
 
         if category:
             if use_v3:
@@ -396,8 +447,8 @@ async def get_memories(
             "has_more": (offset + limit) < total,
         }
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+    except Exception:
+        raise _internal_error("Database error")
 
 
 @router.get("/api/graph")
@@ -430,8 +481,8 @@ async def get_graph(
             },
         }
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Graph error: {str(e)}")
+    except Exception:
+        raise _internal_error("Graph error")
 
 
 @router.post("/api/search")
@@ -455,17 +506,27 @@ async def search_memories(request: Request, body: SearchRequest):
         # directly in an async route blocks the ASGI event loop — Chrome detects
         # a stalled connection and aborts with "signal is aborted without reason"
         # before the response arrives. Fix: run in a thread-pool executor so the
-        # event loop stays alive to send keepalive frames. Also fast=False skips
-        # spreading_activation + Hopfield (saves ~7s on cold graph traversal).
+        # event loop stays alive to send keepalive frames.
+        # v3.4.64 (regression fix): fast=True skips spreading_activation + agentic
+        # LLM rounds (saves ~7s on cold graph traversal). fast=False is the SLOW
+        # path that enables both; the earlier comment had this inverted.
         import asyncio
         import time as _time
         engine = _get_engine(request)
         if engine is not None:
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             t0 = _time.monotonic()
+            # T-window: prefer an explicit ``window`` spec; otherwise derive a
+            # range from the legacy date_from/date_to pair when both are set.
+            _window = getattr(body, "window", None) or ""
+            if not _window and getattr(body, "date_from", None) and getattr(body, "date_to", None):
+                _window = f"{body.date_from}..{body.date_to}"
             response = await loop.run_in_executor(
                 None,
-                lambda: engine.recall(body.query, limit=body.limit, fast=False),
+                lambda: engine.recall(
+                    body.query, limit=body.limit, fast=True,
+                    window=_window or None,
+                ),
             )
             elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
             from superlocalmemory.server.recall_serializer import (
@@ -525,8 +586,8 @@ async def search_memories(request: Request, body: SearchRequest):
             "no_confident_match": False,
         }
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Search error: {str(e)}")
+    except Exception:
+        raise _internal_error("Search error")
     finally:
         end_recall()
 
@@ -611,8 +672,8 @@ async def get_clusters(request: Request):
 
         conn.close()
         return {"clusters": clusters, "total_clusters": len(clusters), "unclustered_count": unclustered}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Cluster error: {str(e)}")
+    except Exception:
+        raise _internal_error("Cluster error")
 
 
 @router.get("/api/clusters/{cluster_id}")
@@ -673,17 +734,19 @@ async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Que
             texts = [m.get("content", "")[:200] for m in members[:10] if m.get("content")]
             if texts:
                 from superlocalmemory.core.summarizer import Summarizer
-                from superlocalmemory.server.profile_runtime import get_profile_runtime
                 from superlocalmemory.server.routes.helpers import get_engine_lazy
 
-                runtime = get_profile_runtime(request.app.state)
-                with runtime.operation():
-                    engine = get_engine_lazy(request.app.state)
-                    if engine is not None:
-                        summarizer = Summarizer(engine._config)
-                        summary = summarizer.summarize_cluster(
-                            [{"content": t} for t in texts]
-                        ) or ""
+                # v3.4.64: Do NOT call runtime.operation() synchronously in an
+                # async route — if a transition is pending, acquire_operation()
+                # blocks the event loop thread, deadlocking the drain.  The
+                # middleware already holds an operation lease for this request;
+                # the engine is stable for the full duration of the handler.
+                engine = get_engine_lazy(request.app.state)
+                if engine is not None:
+                    summarizer = Summarizer(engine._config)
+                    summary = summarizer.summarize_cluster(
+                        [{"content": t} for t in texts]
+                    ) or ""
         except Exception:
             pass
 
@@ -695,8 +758,8 @@ async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Que
         }
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Cluster detail error: {str(e)}")
+    except Exception:
+        raise _internal_error("Cluster detail error")
 
 
 @router.get("/api/memories/{memory_id}/facts")
@@ -710,18 +773,21 @@ async def get_memory_facts(request: Request, memory_id: str):
     engine instead, exactly like the /recall route.
     """
     try:
-        from superlocalmemory.server.profile_runtime import get_profile_runtime
         from superlocalmemory.server.routes.helpers import get_engine_lazy
 
-        runtime = get_profile_runtime(request.app.state)
-        with runtime.operation():
-            engine = get_engine_lazy(request.app.state)
-            if engine is None:
-                raise HTTPException(status_code=503, detail="Engine not initialized")
-            active_profile = engine.profile_id
-            mem_map = engine._db.get_memory_content_batch([memory_id])
-            original = mem_map.get(memory_id, "")
-            facts = engine._db.get_facts_by_memory_id(memory_id, active_profile)
+        # v3.4.64: Do NOT call runtime.operation() synchronously in an async
+        # route — blocks the event loop when a transition is pending.  The
+        # middleware already holds an operation lease; the engine and its
+        # profile_id are stable for the full duration of this request.
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            raise HTTPException(status_code=503, detail="Engine not initialized")
+        active_profile = engine.profile_id
+        mem_map = engine._db.get_memory_content_batch(
+            [memory_id], active_profile, include_global=True, include_shared=True,
+        )
+        original = mem_map.get(memory_id, "")
+        facts = engine._db.get_facts_by_memory_id(memory_id, active_profile)
         fact_list = [
             {
                 "fact_id": f.fact_id,
@@ -744,8 +810,8 @@ async def get_memory_facts(request: Request, memory_id: str):
         }
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+    except Exception:
+        raise _internal_error()
 
 
 @router.get("/api/memories/{memory_id}/detail")
@@ -795,8 +861,8 @@ async def get_memory_detail(request: Request, memory_id: str):
         }
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Detail error: {str(e)}")
+    except Exception:
+        raise _internal_error("Detail error")
 
 
 @router.get("/api/facts/{fact_id}")
@@ -835,8 +901,8 @@ async def get_fact_detail(request: Request, fact_id: str):
         return row
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Fact detail error: {str(e)}")
+    except Exception:
+        raise _internal_error("Fact detail error")
 
 
 @router.delete("/api/memories/{fact_id}")
@@ -859,8 +925,8 @@ async def delete_memory(request: Request, fact_id: str):
         return {"success": True, "deleted": fact_id}
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Delete error: {str(e)}")
+    except Exception:
+        raise _internal_error("Delete error")
 
 
 @router.post("/api/memories/{fact_id}/forget")
@@ -920,8 +986,8 @@ async def forget_memory(request: Request, fact_id: str):
         return {"success": True, "fact_id": fact_id, "archived_at": archived_at}
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Forget error: {str(e)}")
+    except Exception:
+        raise _internal_error("Forget error")
 
 
 @router.post("/api/memories/{fact_id}/merge")
@@ -989,8 +1055,8 @@ async def merge_memory(request: Request, fact_id: str):
         }
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Merge error: {str(e)}")
+    except Exception:
+        raise _internal_error("Merge error")
 
 
 @router.patch("/api/memories/{fact_id}")
@@ -1022,5 +1088,64 @@ async def edit_memory(request: Request, fact_id: str):
         return {"success": True, "fact_id": fact_id, "content": new_content}
     except HTTPException:
         raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Edit error: {str(e)}")
+    except Exception:
+        raise _internal_error("Edit error")
+
+
+_VALID_SCOPES = ("personal", "shared", "global")
+
+
+@router.patch("/api/memories/{fact_id}/scope")
+async def set_memory_scope(request: Request, fact_id: str):
+    """Set a memory's scope (personal | shared | global) + shared_with.
+
+    Body: {"scope": "shared", "shared_with": "alice,bob"}. shared_with accepts a
+    comma-separated string or a list; it is stored as a JSON array so the
+    _scope_where LIKE match works. Mutation-authorized, and the fact must
+    belong to the active profile (a caller cannot re-scope another profile's
+    fact). This is the write side of multi-scope sharing from the dashboard.
+    """
+    import json as _json
+    try:
+        body = await request.json()
+        scope = (body.get("scope") or "").strip().lower()
+        if scope not in _VALID_SCOPES:
+            raise HTTPException(400, detail=f"scope must be one of {_VALID_SCOPES}")
+
+        raw_shared = body.get("shared_with", [])
+        if isinstance(raw_shared, str):
+            shared_list = [s.strip() for s in raw_shared.split(",") if s.strip()]
+        elif isinstance(raw_shared, list):
+            shared_list = [str(s).strip() for s in raw_shared if str(s).strip()]
+        else:
+            shared_list = []
+        if scope == "shared" and not shared_list:
+            raise HTTPException(
+                400, detail="shared scope requires at least one profile in shared_with")
+        # global/personal never carry a shared_with list.
+        if scope != "shared":
+            shared_list = []
+
+        engine, active_profile, _ctx = _authorize_memory_mutation(
+            request, "update", fact_id, run_pre_hook=False,
+        )
+        # Ownership check: the fact must belong to the active profile.
+        rows = engine._db.execute(
+            "SELECT 1 FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+            (fact_id, active_profile),
+        )
+        if not rows:
+            raise HTTPException(404, detail="Memory not found in this profile")
+
+        engine._db.update_fact(fact_id, {
+            "scope": scope,
+            "shared_with": _json.dumps(shared_list),
+        }, profile_id=active_profile)
+        return {
+            "success": True, "fact_id": fact_id, "scope": scope,
+            "shared_with": shared_list, "active_profile": active_profile,
+        }
+    except HTTPException:
+        raise
+    except Exception:
+        raise _internal_error("Scope update error")