superlocalmemory 3.7.8 → 3.8.0

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

@@ -9,8 +9,10 @@ Routes: /api/evolution/status, /api/evolution/enable, /api/evolution/run
 
 import logging
 from pathlib import Path
+from typing import Optional
 
 from fastapi import APIRouter
+from pydantic import BaseModel
 
 from .helpers import get_active_profile, MEMORY_DIR
 
@@ -38,9 +40,10 @@ async def evolution_status():
         backend = detect_backend() if enabled else "none"
         db_path = str(MEMORY_DIR / "memory.db")
 
+        profile_id = get_active_profile()
         store = EvolutionStore(db_path)
-        stats = store.get_stats()
-        recent = store.get_recent(limit=10)
+        stats = store.get_stats(profile_id)
+        recent = store.get_recent(profile_id, limit=10)
 
         return {
             "enabled": enabled,
@@ -48,6 +51,9 @@ async def evolution_status():
             "config": {
                 "backend_setting": evo_cfg.get("backend", "auto"),
                 "max_per_cycle": evo_cfg.get("max_evolutions_per_cycle", 3),
+                "mutation_model": evo_cfg.get("mutation_model", ""),
+                "verify_model": evo_cfg.get("verify_model", ""),
+                "confirm_model": evo_cfg.get("confirm_model", ""),
             },
             "stats": {
                 "total": stats.get("total", 0),
@@ -70,9 +76,9 @@ async def evolution_status():
                 for r in recent
             ],
         }
-    except Exception as e:
-        logger.debug("evolution_status error: %s", e)
-        return {"enabled": False, "backend": "none", "error": str(e)}
+    except Exception:
+        logger.exception("evolution_status error")
+        return {"enabled": False, "backend": "none", "error": "Internal server error"}
 
 
 @router.post("/api/evolution/enable")
@@ -96,9 +102,38 @@ async def evolution_enable():
             _json.dump(cfg, f, indent=2)
 
         return {"ok": True, "message": "Evolution enabled. Will use auto-detected backend."}
-    except Exception as e:
-        logger.error("evolution_enable error: %s", e)
-        return {"ok": False, "error": str(e)}
+    except Exception:
+        logger.exception("evolution_enable error")
+        return {"ok": False, "error": "Internal server error"}
+
+
+@router.post("/api/evolution/disable")
+async def evolution_disable():
+    """Disable skill evolution engine.  Mirrors /api/evolution/enable."""
+    try:
+        import json as _json
+        import os as _os
+
+        config_path = MEMORY_DIR / "config.json"
+        cfg: dict = {}
+        if config_path.exists():
+            with open(config_path) as f:
+                cfg = _json.load(f)
+
+        if "evolution" not in cfg:
+            cfg["evolution"] = {}
+        cfg["evolution"]["enabled"] = False
+
+        # Atomic write — protect against truncated config.json on crash.
+        tmp = config_path.with_suffix(".json.evo_disable_tmp")
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp.write_text(_json.dumps(cfg, indent=2), encoding="utf-8")
+        _os.replace(tmp, config_path)
+
+        return {"ok": True, "message": "Evolution disabled."}
+    except Exception:
+        logger.exception("evolution_disable error")
+        return {"ok": False, "error": "Internal server error"}
 
 
 @router.post("/api/evolution/run")
@@ -120,11 +155,17 @@ async def evolution_run():
         profile = get_active_profile()
         db_path = str(MEMORY_DIR / "memory.db")
 
-        # Build a minimal config object for the evolver
+        # Build a minimal config object for the evolver. Must carry the
+        # per-step model fields (v3.7.9) or a dashboard-triggered run would
+        # silently ignore the user's configured models and fall back to the
+        # cheapest defaults.
         class _EvoCfg:
             enabled = True
             backend = evo_cfg.get("backend", "auto")
             max_evolutions_per_cycle = evo_cfg.get("max_evolutions_per_cycle", 3)
+            mutation_model = evo_cfg.get("mutation_model", "")
+            verify_model = evo_cfg.get("verify_model", "")
+            confirm_model = evo_cfg.get("confirm_model", "")
         class _Cfg:
             evolution = _EvoCfg()
 
@@ -132,9 +173,83 @@ async def evolution_run():
         result = evolver.run_consolidation_cycle(profile)
 
         return {"ok": True, **result}
-    except Exception as e:
-        logger.error("evolution_run error: %s", e)
-        return {"ok": False, "error": str(e)}
+    except Exception:
+        logger.exception("evolution_run error")
+        return {"ok": False, "error": "Internal server error"}
+
+
+class EvolutionConfigUpdate(BaseModel):
+    enabled: Optional[bool] = None
+    backend: Optional[str] = None
+    max_evolutions_per_cycle: Optional[int] = None
+    mutation_model: Optional[str] = None
+    verify_model: Optional[str] = None
+    confirm_model: Optional[str] = None
+
+
+@router.post("/api/evolution/config")
+async def evolution_config(body: EvolutionConfigUpdate):
+    """Update evolution config from the dashboard (v3.7.9).
+
+    Validates model + backend values against the same allow-list the CLI uses
+    (``slm config set evolution.*``) and persists to config.json atomically.
+    Only fields provided in the body are changed.
+    """
+    try:
+        import json as _json
+        import os as _os
+        from superlocalmemory.evolution.model_selection import _MODEL_ALIASES
+
+        accepted_models = set(_MODEL_ALIASES) | {"", "auto"}
+        accepted_backends = {"auto", "claude", "ollama", "anthropic", "openai"}
+
+        for field in ("mutation_model", "verify_model", "confirm_model"):
+            val = getattr(body, field)
+            if val is not None and val not in accepted_models:
+                allowed = ", ".join(["auto", *sorted(_MODEL_ALIASES)])
+                return {"ok": False, "error": f"{field} must be one of: {allowed}"}
+        if body.backend is not None and body.backend not in accepted_backends:
+            return {
+                "ok": False,
+                "error": f"backend must be one of: {', '.join(sorted(accepted_backends))}",
+            }
+        if (body.max_evolutions_per_cycle is not None
+                and not 0 < body.max_evolutions_per_cycle <= 50):
+            return {"ok": False, "error": "max_evolutions_per_cycle must be 1..50"}
+
+        config_path = MEMORY_DIR / "config.json"
+        cfg = {}
+        if config_path.exists():
+            with open(config_path) as f:
+                cfg = _json.load(f)
+        evo = cfg.setdefault("evolution", {})
+
+        for field in ("enabled", "backend", "max_evolutions_per_cycle",
+                      "mutation_model", "verify_model", "confirm_model"):
+            val = getattr(body, field)
+            if val is None:
+                continue
+            # "auto" is the UI label for the resolver's "" (pick cheapest model).
+            if field.endswith("_model") and val == "auto":
+                val = ""
+            evo[field] = val
+
+        # Atomic write — a truncated config.json would brick every slm call.
+        tmp = config_path.with_suffix(".json.evo_tmp")
+        tmp.write_text(_json.dumps(cfg, indent=2), encoding="utf-8")
+        _os.replace(tmp, config_path)
+
+        return {"ok": True, "config": {
+            "enabled": evo.get("enabled", False),
+            "backend": evo.get("backend", "auto"),
+            "max_evolutions_per_cycle": evo.get("max_evolutions_per_cycle", 3),
+            "mutation_model": evo.get("mutation_model", ""),
+            "verify_model": evo.get("verify_model", ""),
+            "confirm_model": evo.get("confirm_model", ""),
+        }}
+    except Exception:
+        logger.exception("evolution_config error")
+        return {"ok": False, "error": "Internal server error"}
 
 
 @router.get("/api/evolution/lineage")
@@ -147,6 +262,7 @@ async def evolution_lineage(skill_name: str = ""):
         import sqlite3 as _sqlite3
 
         db_path = str(MEMORY_DIR / "memory.db")
+        profile_id = get_active_profile()
         conn = _sqlite3.connect(db_path, timeout=10)
         conn.row_factory = _sqlite3.Row
 
@@ -156,9 +272,9 @@ async def evolution_lineage(skill_name: str = ""):
                 "trigger_type, generation, status, mutation_summary, "
                 "blind_verified, created_at, completed_at "
                 "FROM skill_evolution_log "
-                "WHERE skill_name = ? OR parent_skill_id = ? "
+                "WHERE profile_id = ? AND (skill_name = ? OR parent_skill_id = ?) "
                 "ORDER BY created_at ASC",
-                (skill_name, skill_name),
+                (profile_id, skill_name, skill_name),
             ).fetchall()
         else:
             rows = conn.execute(
@@ -166,7 +282,9 @@ async def evolution_lineage(skill_name: str = ""):
                 "trigger_type, generation, status, mutation_summary, "
                 "blind_verified, created_at, completed_at "
                 "FROM skill_evolution_log "
+                "WHERE profile_id = ? "
                 "ORDER BY created_at DESC LIMIT 100",
+                (profile_id,),
             ).fetchall()
 
         conn.close()
@@ -208,6 +326,6 @@ async def evolution_lineage(skill_name: str = ""):
             "lineage_count": len(lineage),
             "tree": tree,
         }
-    except Exception as e:
-        logger.debug("evolution_lineage error: %s", e)
-        return {"lineage": [], "lineage_count": 0, "tree": {}, "error": str(e)}
+    except Exception:
+        logger.exception("evolution_lineage error")
+        return {"lineage": [], "lineage_count": 0, "tree": {}, "error": "Internal server error"}

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

@@ -342,12 +342,23 @@ def set_active_profile_everywhere(name: str) -> None:
 
 
 def delete_profile_from_db(name: str) -> None:
-    """Delete a profile row from SQLite. ON DELETE CASCADE handles child rows."""
+    """Delete a profile row from SQLite.
+
+    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.
+    """
     if not DB_PATH.exists():
         return
     conn = sqlite3.connect(str(DB_PATH))
     try:
         conn.execute("PRAGMA foreign_keys=ON")
+        # Purge role grants for this workspace (no FK CASCADE covers these).
+        for tbl in ("rbac_memberships",):
+            try:
+                conn.execute(f"DELETE FROM {tbl} WHERE profile_id = ?", (name,))
+            except sqlite3.OperationalError:
+                pass  # table may not exist on older installs
         conn.execute("DELETE FROM profiles WHERE profile_id = ?", (name,))
         conn.commit()
     finally:
@@ -420,6 +431,10 @@ class SearchRequest(BaseModel):
     cluster_id: Optional[int] = None
     date_from: Optional[str] = None
     date_to: Optional[str] = None
+    # T-window: relative span ("7d", "30d", "1y") or explicit range
+    # ("2026-07-01..2026-07-31"). When empty, date_from/date_to (if both set)
+    # are used as the range. Empty + no dates = no time filter.
+    window: Optional[str] = None
 
 
 class ProfileSwitch(BaseModel):

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

@@ -18,7 +18,7 @@ import threading
 from datetime import datetime, timezone
 
 from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 router = APIRouter(tags=["ingestion"])
 
@@ -28,7 +28,9 @@ _active_lock = threading.Lock()
 
 
 class IngestRequest(BaseModel):
-    content: str
+    # Cap ingest content (~1 MB) so a single call cannot exhaust memory through
+    # the embedding/tokenizer pipeline.
+    content: str = Field(..., max_length=1_000_000)
     source_type: str
     dedup_key: str
     metadata: dict = {}
@@ -99,9 +101,10 @@ async def ingest(req: IngestRequest, request: Request):
         # truth; retries repair this row without repeating the canonical write.
         engine._db.execute(
             "INSERT OR IGNORE INTO ingestion_log "
-            "(source_type, dedup_key, fact_ids, metadata, status, ingested_at) "
-            "VALUES (?, ?, ?, ?, 'ingested', ?)",
+            "(profile_id, source_type, dedup_key, fact_ids, metadata, status, ingested_at) "
+            "VALUES (?, ?, ?, ?, ?, 'ingested', ?)",
             (
+                engine._profile_id,
                 req.source_type,
                 req.dedup_key,
                 json.dumps(fact_ids),

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

@@ -358,10 +358,10 @@ async def insight_action(
         result = handler(conn, pid, limit=limit, days=days)
         result["profile"] = pid
         return result
-    except Exception as exc:
-        logger.warning("Insight action %s failed: %s", action_name, exc)
+    except Exception:
+        logger.exception("Insight action %s failed", action_name)
         return JSONResponse(
-            {"error": f"Query failed: {exc}"},
+            {"error": "Query failed"},
             status_code=500,
         )
     finally:

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

@@ -291,8 +291,8 @@ async def learning_status():
         result["source_scores"] = {}
 
     except Exception as e:
-        logger.error("Error getting learning status: %s", e)
-        result["error"] = str(e)
+        logger.exception("Error getting learning status")
+        result["error"] = "Internal server error"
 
     return result
 
@@ -334,8 +334,8 @@ async def record_feedback(data: dict):
             "feedback_id": row_id,
         }
     except Exception as e:
-        logger.error("Error recording feedback: %s", e)
-        return {"success": False, "error": str(e)}
+        logger.exception("Error recording feedback")
+        return {"success": False, "error": "Internal server error"}
 
 
 @router.post("/api/feedback/dwell")
@@ -379,8 +379,8 @@ async def record_dwell(data: dict):
             "feedback_id": row_id,
         }
     except Exception as e:
-        logger.error("Error recording dwell: %s", e)
-        return {"success": False, "error": str(e)}
+        logger.exception("Error recording dwell")
+        return {"success": False, "error": "Internal server error"}
 
 
 @router.get("/api/feedback/stats")
@@ -414,8 +414,8 @@ async def feedback_stats():
             "by_channel": by_channel, "by_type": by_type, "available": True,
         }
     except Exception as e:
-        logger.error("Error getting feedback stats: %s", e)
-        return {"total_signals": 0, "ranking_phase": "baseline", "progress": 0, "error": str(e)}
+        logger.exception("Error getting feedback stats")
+        return {"total_signals": 0, "ranking_phase": "baseline", "progress": 0, "error": "Internal server error"}
 
 
 # ============================================================================
@@ -455,7 +455,7 @@ async def delete_pattern(data: dict) -> dict:
         }
     except Exception as exc:  # noqa: BLE001
         logger.error("delete_pattern failed: %s", exc)
-        return {"success": False, "error": str(exc)}
+        return {"success": False, "error": "internal error"}
 
 
 @router.get("/api/patterns")
@@ -562,8 +562,8 @@ async def learning_backup():
             "message": f"Learning DB backed up to {backup_name}",
         }
     except Exception as e:
-        logger.error("Error backing up learning DB: %s", e)
-        return {"success": False, "error": str(e)}
+        logger.exception("Error backing up learning DB")
+        return {"success": False, "error": "Internal server error"}
 
 
 @router.post("/api/learning/reset")
@@ -583,7 +583,7 @@ async def learning_reset():
         }
     except Exception as exc:  # noqa: BLE001
         logger.error("learning_reset failed: %s", exc)
-        return {"success": False, "error": str(exc)}
+        return {"success": False, "error": "internal error"}
 
 
 @router.post("/api/learning/retrain")
@@ -643,7 +643,7 @@ async def learning_retrain(data: dict | None = None):
         }
     except Exception as exc:  # noqa: BLE001
         logger.error("learning_retrain failed: %s", exc)
-        return {"success": False, "error": str(exc)}
+        return {"success": False, "error": "internal error"}
 
 
 @router.post("/api/learning/migrate-legacy")
@@ -665,4 +665,4 @@ async def learning_migrate_legacy():
         return {"success": True, **stats}
     except Exception as exc:  # noqa: BLE001
         logger.error("learning_migrate_legacy failed: %s", exc)
-        return {"success": False, "error": str(exc)}
+        return {"success": False, "error": "internal error"}

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"}