superlocalmemory 3.6.23 → 3.7.0

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

@@ -25,6 +25,44 @@ def _get_engine(request: Request):
     return get_engine_lazy(request.app.state)
 
 
+def _authorize_memory_mutation(
+    request: Request,
+    operation: str,
+    fact_id: str,
+    *,
+    content_preview: str = "",
+    run_pre_hook: bool = True,
+):
+    """Authenticate a mutation, optionally gating route-owned direct SQL."""
+    from superlocalmemory.server.write_identity import require_write_actor
+
+    actor_id = require_write_actor(
+        request,
+        getattr(request.app.state, "daemon_descriptor", None),
+        actor_kind="dashboard",
+    )
+    engine = _get_engine(request)
+    if engine is None:
+        raise HTTPException(503, detail="Engine not initialized")
+    profile_id = engine.profile_id
+    context = {
+        "operation": operation,
+        "agent_id": actor_id,
+        "source_agent_id": "dashboard",
+        "profile_id": profile_id,
+        "fact_id": fact_id,
+    }
+    if content_preview:
+        context["content_preview"] = content_preview[:100]
+    if run_pre_hook:
+        try:
+            engine._hooks.run_pre(operation, context)
+        except Exception as exc:
+            logger.warning("Dashboard %s authorization rejected: %s", operation, exc)
+            raise HTTPException(403, detail="Write authorization rejected") from exc
+    return engine, profile_id, context
+
+
 def _preview(content: str | None) -> str:
     """Truncate content for preview display."""
     if not content:
@@ -430,23 +468,24 @@ async def search_memories(request: Request, body: SearchRequest):
                 lambda: engine.recall(body.query, limit=body.limit, fast=False),
             )
             elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
-            results = []
-            for r in response.results[: body.limit]:
-                results.append({
-                    "fact_id": r.fact.fact_id,
-                    "memory_id": getattr(r.fact, "memory_id", ""),
-                    "content": r.fact.content[:300],
-                    "score": round(r.score, 4),
-                    "confidence": round(getattr(r, "confidence", 0.0), 4),
-                    "channel_scores": getattr(r, "channel_scores", {}),
-                    "created_at": getattr(r.fact, "created_at", ""),
-                })
+            from superlocalmemory.server.recall_serializer import (
+                recall_response_metadata,
+                serialize_recall_response,
+            )
+            results, no_confident_match = serialize_recall_response(
+                response,
+                limit=body.limit,
+                per_fact_max=300,
+                total_max=max(300, body.limit * 300),
+            )
             return {
                 "query": body.query,
                 "results": results,
                 "total": len(results),
                 "query_type": getattr(response, "query_type", "semantic"),
                 "retrieval_time_ms": elapsed_ms,
+                "no_confident_match": no_confident_match,
+                **recall_response_metadata(response),
             }
 
         # Fallback: direct DB text search (engine not yet initialised)
@@ -455,18 +494,35 @@ async def search_memories(request: Request, body: SearchRequest):
         cursor = conn.cursor()
         active_profile = get_active_profile()
         cursor.execute("""
-            SELECT fact_id as id, content, confidence as score,
+            SELECT fact_id, content, confidence as memory_confidence,
                    fact_type as category, created_at
             FROM atomic_facts
             WHERE profile_id = ? AND content LIKE ?
             ORDER BY confidence DESC LIMIT ?
         """, (active_profile, f'%{body.query}%', body.limit))
-        results = cursor.fetchall()
+        rows = cursor.fetchall()
         conn.close()
 
+        results = [{
+            **row,
+            "score": None,
+            "relevance_score": None,
+            "ranking_score": None,
+            "confidence": row.get("memory_confidence"),
+            "rank_position": position,
+        } for position, row in enumerate(rows, start=1)]
+
         return {
             "query": body.query, "results": results, "total": len(results),
             "query_type": "text_search", "retrieval_time_ms": 0,
+            "retrieval_mode": "degraded_lexical",
+            "score_contract_version": "2",
+            "calibration_status": "uncalibrated",
+            "calibration_id": None,
+            "answer_confidence": None,
+            "abstained": not bool(results),
+            "abstention_reason": None if results else "no_candidates",
+            "no_confident_match": False,
         }
 
     except Exception as e:
@@ -739,22 +795,20 @@ async def get_fact_detail(request: Request, fact_id: str):
 @router.delete("/api/memories/{fact_id}")
 async def delete_memory(request: Request, fact_id: str):
     """Delete a specific memory (atomic fact) by ID."""
+    engine, _active_profile, hook_context = _authorize_memory_mutation(
+        request, "delete", fact_id, run_pre_hook=False,
+    )
     try:
-        conn = get_db_connection()
-        conn.row_factory = dict_factory
-        cursor = conn.cursor()
-        active_profile = get_active_profile()
-        # Verify it exists and belongs to this profile
-        cursor.execute(
-            "SELECT fact_id FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
-            (fact_id, active_profile),
+        from superlocalmemory.core.mutations import delete_fact_authorized
+
+        result = delete_fact_authorized(
+            engine,
+            fact_id,
+            trusted_actor_id=hook_context["agent_id"],
+            source_agent_id="dashboard",
         )
-        if not cursor.fetchone():
-            conn.close()
+        if not result.get("ok"):
             raise HTTPException(status_code=404, detail="Memory not found")
-        cursor.execute("DELETE FROM atomic_facts WHERE fact_id = ?", (fact_id,))
-        conn.commit()
-        conn.close()
         return {"success": True, "deleted": fact_id}
     except HTTPException:
         raise
@@ -772,11 +826,13 @@ async def forget_memory(request: Request, fact_id: str):
     future ``slm restore`` can bring it back.
     """
     import json as _json
+    engine, active_profile, hook_context = _authorize_memory_mutation(
+        request, "delete", fact_id,
+    )
     try:
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()
-        active_profile = get_active_profile()
         cursor.execute(
             "SELECT fact_id, content, importance, confidence, "
             "       canonical_entities_json, embedding, created_at "
@@ -813,6 +869,7 @@ async def forget_memory(request: Request, fact_id: str):
         )
         conn.commit()
         conn.close()
+        engine._hooks.run_post("delete", hook_context)
         return {"success": True, "fact_id": fact_id, "archived_at": archived_at}
     except HTTPException:
         raise
@@ -830,6 +887,9 @@ async def merge_memory(request: Request, fact_id: str):
     the loser's ``merged_into`` column. The loser is archived so it
     no longer appears in default recall. The winner is untouched.
     """
+    engine, active_profile, hook_context = _authorize_memory_mutation(
+        request, "delete", fact_id,
+    )
     try:
         body = await request.json()
         kept = str((body or {}).get("into", "")).strip()
@@ -843,7 +903,6 @@ async def merge_memory(request: Request, fact_id: str):
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()
-        active_profile = get_active_profile()
         # Both must belong to the active profile.
         cursor.execute(
             "SELECT fact_id FROM atomic_facts "
@@ -874,6 +933,7 @@ async def merge_memory(request: Request, fact_id: str):
         )
         conn.commit()
         conn.close()
+        engine._hooks.run_post("delete", hook_context)
         return {
             "success": True,
             "merged": fact_id,
@@ -894,23 +954,24 @@ async def edit_memory(request: Request, fact_id: str):
         new_content = (body.get("content") or "").strip()
         if not new_content:
             raise HTTPException(status_code=400, detail="content is required")
-        conn = get_db_connection()
-        conn.row_factory = dict_factory
-        cursor = conn.cursor()
-        active_profile = get_active_profile()
-        cursor.execute(
-            "SELECT fact_id FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
-            (fact_id, active_profile),
+        engine, _active_profile, hook_context = _authorize_memory_mutation(
+            request,
+            "update",
+            fact_id,
+            content_preview=new_content,
+            run_pre_hook=False,
         )
-        if not cursor.fetchone():
-            conn.close()
-            raise HTTPException(status_code=404, detail="Memory not found")
-        cursor.execute(
-            "UPDATE atomic_facts SET content = ? WHERE fact_id = ?",
-            (new_content, fact_id),
+        from superlocalmemory.core.mutations import update_fact_authorized
+
+        result = update_fact_authorized(
+            engine,
+            fact_id,
+            new_content,
+            trusted_actor_id=hook_context["agent_id"],
+            source_agent_id="dashboard",
         )
-        conn.commit()
-        conn.close()
+        if not result.get("ok"):
+            raise HTTPException(status_code=404, detail="Memory not found")
         return {"success": True, "fact_id": fact_id, "content": new_content}
     except HTTPException:
         raise

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

@@ -11,6 +11,7 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import re
 from typing import Optional
 
 from fastapi import APIRouter, HTTPException, Request
@@ -104,9 +105,38 @@ def _get_broker(request: Request):
             )
             if not presented or not hmac.compare_digest(presented, secret):
                 raise HTTPException(401, detail="invalid or missing credential")
+            return broker
+
+    # Loopback is a transport property, not an identity.  Every mesh read and
+    # write must prove the install/API/process capability because peer inboxes,
+    # coordination state, and project paths can be sensitive.
+    from superlocalmemory.server.write_identity import require_write_actor
+
+    require_write_actor(
+        request,
+        getattr(request.app.state, "daemon_descriptor", None),
+        actor_kind="mesh-route",
+    )
     return broker
 
 
+_SECRET_KEY = re.compile(
+    r"(?:^|[_\-.])(api[_\-.]?key|secret|token|password|credential)(?:$|[_\-.])",
+    re.IGNORECASE,
+)
+
+
+def _reject_secret_state(key: str, value: str) -> None:
+    """Refuse secret material in the plaintext coordination store."""
+    from superlocalmemory.core.security_primitives import redact_secrets
+
+    if _SECRET_KEY.search(key) or redact_secrets(value) != value:
+        raise HTTPException(
+            422,
+            detail="Mesh state is coordination metadata; secret values are prohibited",
+        )
+
+
 # -- Routes --
 
 @router.post("/register")
@@ -197,6 +227,7 @@ async def state_set(req: StateSetRequest, request: Request):
     broker = _get_broker(request)
     if not req.key:
         raise HTTPException(400, detail="key required")
+    _reject_secret_state(req.key, req.value)
     return broker.set_state(req.key, req.value, req.set_by)
 
 

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

@@ -13,7 +13,9 @@ is kept in sync as a cache for backward compatibility.
 import logging
 from datetime import datetime, timezone
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Request
+
+from superlocalmemory.server.route_mutations import authorize_route_mutation
 
 from .helpers import (
     get_db_connection, validate_profile_name,
@@ -84,7 +86,7 @@ async def list_profiles():
 
 
 @router.post("/api/profiles/{name}/switch")
-async def switch_profile(name: str):
+async def switch_profile(name: str, request: Request):
     """Switch active memory profile (persists to both config stores)."""
     try:
         if not validate_profile_name(name):
@@ -100,6 +102,12 @@ async def switch_profile(name: str):
                 detail=f"Profile '{name}' not found. Available: {available}",
             )
 
+        authorization = authorize_route_mutation(
+            request,
+            operation="update",
+            source_agent_id="http-profile-switch",
+            profile_id=name,
+        )
         previous = _load_profiles_json().get('active_profile', 'default')
         set_active_profile_everywhere(name)
 
@@ -118,6 +126,7 @@ async def switch_profile(name: str):
                 "timestamp": datetime.now(timezone.utc).isoformat(),
             })
 
+        authorization.complete()
         return {
             "success": True, "active_profile": name,
             "previous_profile": previous, "memory_count": count,
@@ -131,7 +140,7 @@ async def switch_profile(name: str):
 
 
 @router.post("/api/profiles/create")
-async def create_profile(body: ProfileSwitch):
+async def create_profile(body: ProfileSwitch, request: Request):
     """Create a new memory profile (writes to BOTH SQLite and profiles.json)."""
     try:
         name = body.profile_name
@@ -144,11 +153,17 @@ async def create_profile(body: ProfileSwitch):
         if name in merged_ids:
             raise HTTPException(status_code=409, detail=f"Profile '{name}' already exists")
 
+        authorization = authorize_route_mutation(
+            request,
+            operation="update",
+            source_agent_id="http-profile-create",
+        )
         # Write to BOTH stores atomically
         desc = f'Memory profile: {name}'
         ensure_profile_in_db(name, desc)
         ensure_profile_in_json(name, desc)
 
+        authorization.complete()
         return {"success": True, "profile": name, "message": f"Profile '{name}' created"}
 
     except HTTPException:
@@ -158,7 +173,7 @@ async def create_profile(body: ProfileSwitch):
 
 
 @router.delete("/api/profiles/{name}")
-async def delete_profile(name: str):
+async def delete_profile(name: str, request: Request):
     """Delete a profile. Moves its memories to 'default'."""
     try:
         if name == 'default':
@@ -173,6 +188,12 @@ async def delete_profile(name: str):
         if json_config.get('active_profile') == name:
             raise HTTPException(status_code=400, detail="Cannot delete active profile.")
 
+        authorization = authorize_route_mutation(
+            request,
+            operation="delete",
+            source_agent_id="http-profile-delete",
+            profile_id=name,
+        )
         # Move data to default before deleting (bypasses CASCADE)
         conn = get_db_connection()
         cursor = conn.cursor()
@@ -204,6 +225,7 @@ async def delete_profile(name: str):
         json_config['profiles'] = profiles
         _save_profiles_json(json_config)
 
+        authorization.complete()
         return {
             "success": True,
             "message": f"Profile '{name}' deleted. {moved} memories moved to 'default'.",

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

@@ -18,6 +18,8 @@ from datetime import datetime, UTC
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
+from superlocalmemory.server.route_mutations import authorize_route_mutation
+
 from .helpers import DB_PATH
 
 logger = logging.getLogger("superlocalmemory.routes.tiers")
@@ -105,6 +107,12 @@ async def evaluate_tiers_route(request: Request, profile_id: str = "default"):
     profile_id = _validate_profile(profile_id)
 
     try:
+        authorization = authorize_route_mutation(
+            request,
+            operation="update",
+            source_agent_id="http-tier-evaluate",
+            profile_id=profile_id,
+        )
         from superlocalmemory.core.tier_manager import evaluate_tiers
         from .helpers import get_engine_lazy
 
@@ -114,6 +122,7 @@ async def evaluate_tiers_route(request: Request, profile_id: str = "default"):
                 status_code=503, detail="Engine not initialized",
             )
         stats = evaluate_tiers(engine._db, profile_id)
+        authorization.complete()
         return {"success": True, "stats": stats}
     except HTTPException:
         raise
@@ -125,12 +134,23 @@ async def evaluate_tiers_route(request: Request, profile_id: str = "default"):
 
 
 @router.post("/api/tiers/pin")
-async def pin_fact_route(request: PinRequest, profile_id: str = "default"):
+async def pin_fact_route(
+    body: PinRequest,
+    request: Request,
+    profile_id: str = "default",
+):
     """Pin a fact to stay in active tier forever.
 
     Validates fact exists in the specified profile before pinning.
     """
     profile_id = _validate_profile(profile_id)
+    authorization = authorize_route_mutation(
+        request,
+        operation="update",
+        source_agent_id="http-tier-pin",
+        profile_id=profile_id,
+        fact_id=body.fact_id,
+    )
 
     with _db() as conn:
         try:
@@ -139,12 +159,12 @@ async def pin_fact_route(request: PinRequest, profile_id: str = "default"):
             c.execute(
                 "SELECT fact_id FROM atomic_facts "
                 "WHERE fact_id = ? AND profile_id = ?",
-                (request.fact_id, profile_id),
+                (body.fact_id, profile_id),
             )
             if c.fetchone() is None:
                 raise HTTPException(
                     status_code=404,
-                    detail=f"Fact {request.fact_id[:8]}... not found",
+                    detail=f"Fact {body.fact_id[:8]}... not found",
                 )
 
             now = datetime.now(UTC).isoformat()
@@ -152,15 +172,15 @@ async def pin_fact_route(request: PinRequest, profile_id: str = "default"):
                 "INSERT OR REPLACE INTO pinned_facts "
                 "(fact_id, profile_id, pinned_at, reason) "
                 "VALUES (?, ?, ?, ?)",
-                (request.fact_id, profile_id, now, request.reason),
+                (body.fact_id, profile_id, now, body.reason),
             )
-            conn.execute(
-                "UPDATE atomic_facts SET lifecycle = 'active' "
-                "WHERE fact_id = ? AND profile_id = ?",
-                (request.fact_id, profile_id),
+            from superlocalmemory.core.lifecycle_state import set_fact_lifecycle_zone
+            set_fact_lifecycle_zone(
+                conn, [body.fact_id], "active", profile_id=profile_id,
             )
             conn.commit()
-            return {"success": True, "message": f"Fact {request.fact_id[:8]}... pinned"}
+            authorization.complete()
+            return {"success": True, "message": f"Fact {body.fact_id[:8]}... pinned"}
         except HTTPException:
             raise
         except Exception as exc:
@@ -171,7 +191,11 @@ async def pin_fact_route(request: PinRequest, profile_id: str = "default"):
 
 
 @router.post("/api/tiers/unpin")
-async def unpin_fact_route(request: PinRequest, profile_id: str = "default"):
+async def unpin_fact_route(
+    body: PinRequest,
+    request: Request,
+    profile_id: str = "default",
+):
     """Unpin a fact, allowing normal tier demotion.
 
     Lifecycle stays 'active' until the next tier evaluation cycle demotes it
@@ -179,14 +203,22 @@ async def unpin_fact_route(request: PinRequest, profile_id: str = "default"):
     surprise the user.
     """
     profile_id = _validate_profile(profile_id)
+    authorization = authorize_route_mutation(
+        request,
+        operation="update",
+        source_agent_id="http-tier-unpin",
+        profile_id=profile_id,
+        fact_id=body.fact_id,
+    )
 
     with _db() as conn:
         try:
             conn.execute(
                 "DELETE FROM pinned_facts WHERE fact_id = ? AND profile_id = ?",
-                (request.fact_id, profile_id),
+                (body.fact_id, profile_id),
             )
             conn.commit()
+            authorization.complete()
             return {"success": True, "unpinned": True}
         except Exception as exc:
             logger.error("unpin_fact failed: %s", exc, exc_info=True)

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

@@ -24,7 +24,11 @@ logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/v3/timeline", tags=["timeline"])
 
 VALID_RANGES = {"1d", "7d", "30d", "90d", "365d"}
-VALID_GROUP_BY = {"category", "community"}
+# ``date`` is the dashboard's chronological view.  It does not need an extra
+# enrichment pass because each returned event already carries its timestamp,
+# but it is a first-class grouping selection and must not be rejected at the
+# API boundary.
+VALID_GROUP_BY = {"category", "community", "date"}
 INTERNAL_CEILING = 5000