superlocalmemory 3.7.7 → 3.8.0

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}")
@@ -662,14 +723,30 @@ async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Que
         if not members:
             raise HTTPException(status_code=404, detail="Cluster not found")
         # Generate cluster summary
+        # v3.7.8: previously routed through WorkerPool.shared(), a subprocess
+        # cache never recycled on a profile switch (CRITICAL cross-profile
+        # leak — up to 120s stale). Use the daemon's own resident,
+        # lease-protected engine's config instead; the summarizer only
+        # consumes already profile-filtered `texts` above, so this closes
+        # the stale-engine window without changing behavior.
         summary = ""
         try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            pool = WorkerPool.shared()
             texts = [m.get("content", "")[:200] for m in members[:10] if m.get("content")]
             if texts:
-                result = pool.summarize(texts)
-                summary = result.get("summary", "") if result.get("ok") else ""
+                from superlocalmemory.core.summarizer import Summarizer
+                from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+                # 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
 
@@ -681,24 +758,60 @@ 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")
 async def get_memory_facts(request: Request, memory_id: str):
-    """Get original memory text with all its child atomic facts."""
+    """Get original memory text with all its child atomic facts.
+
+    v3.7.8: previously routed through WorkerPool.shared(), a subprocess
+    engine cached at process init and never recycled on a profile switch
+    (CRITICAL cross-profile leak — served the OLD profile's facts for up to
+    120s after a switch). Uses the daemon's own resident, lease-protected
+    engine instead, exactly like the /recall route.
+    """
     try:
-        from superlocalmemory.core.worker_pool import WorkerPool
-        pool = WorkerPool.shared()
-        result = pool.get_memory_facts(memory_id)
-        if result.get("ok"):
-            return result
-        raise HTTPException(status_code=404, detail="Memory not found")
+        from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+        # 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,
+                "content": f.content,
+                "fact_type": (
+                    f.fact_type.value if hasattr(f.fact_type, "value")
+                    else str(f.fact_type)
+                ),
+                "confidence": round(f.confidence, 3),
+                "created_at": f.created_at,
+            }
+            for f in facts
+        ]
+        return {
+            "ok": True,
+            "memory_id": memory_id,
+            "original_content": original,
+            "facts": fact_list,
+            "fact_count": len(fact_list),
+        }
     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")
@@ -748,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}")
@@ -788,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}")
@@ -812,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")
@@ -873,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")
@@ -942,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}")
@@ -975,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")

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

@@ -11,6 +11,7 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import asyncio
 import re
 from typing import Optional
 
@@ -120,6 +121,19 @@ def _get_broker(request: Request):
     return broker
 
 
+def _active_profile() -> str:
+    """Resolve the tenant (profile) for this mesh request.
+
+    The mesh is a per-tenant coordination bus: peers, messages, shared state,
+    and locks are all scoped to the active profile so one tenant never sees
+    another's coordination traffic. Resolved from the request ContextVar set by
+    ProfileRuntimeMiddleware (falls back to the configured active profile).
+    """
+    from superlocalmemory.server.routes.helpers import get_active_profile
+
+    return get_active_profile()
+
+
 _SECRET_KEY = re.compile(
     r"(?:^|[_\-.])(api[_\-.]?key|secret|token|password|credential)(?:$|[_\-.])",
     re.IGNORECASE,
@@ -146,29 +160,79 @@ async def register(req: RegisterRequest, request: Request):
         raise HTTPException(400, detail="session_id required")
     return broker.register_peer(
         req.session_id, req.summary, req.host, req.port,
-        req.project_path, req.agent_type,
+        req.project_path, req.agent_type, profile_id=_active_profile(),
     )
 
 
 @router.post("/deregister")
 async def deregister(req: DeregisterRequest, request: Request):
     broker = _get_broker(request)
-    result = broker.deregister_peer(req.peer_id)
+    result = broker.deregister_peer(req.peer_id, profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
 
 
+def _peer_activity_counts(request: Request, session_ids: list[str]) -> dict:
+    """Per-session {tool_count, memory_count} for the active profile.
+
+    Each mesh peer IS an agent session, so its activity is the tool events it
+    logged and the memories it contributed under the current profile. Batched
+    to a single grouped query per table. Fail-soft: returns {} on any error so
+    the peer list still renders.
+    """
+    if not session_ids:
+        return {}
+    try:
+        from superlocalmemory.server.routes.helpers import (
+            get_engine_lazy, get_active_profile,
+        )
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            return {}
+        profile = get_active_profile()
+        placeholders = ",".join("?" * len(session_ids))
+        params = [profile, *session_ids]
+        counts: dict[str, dict] = {sid: {"tool_count": 0, "memory_count": 0}
+                                   for sid in session_ids}
+        for table, key in (("tool_events", "tool_count"),
+                            ("memories", "memory_count")):
+            try:
+                rows = engine._db.execute(
+                    f"SELECT session_id, COUNT(*) AS n FROM {table} "
+                    f"WHERE profile_id = ? AND session_id IN ({placeholders}) "
+                    "GROUP BY session_id",
+                    tuple(params),
+                )
+                for r in rows:
+                    d = dict(r)
+                    sid = d.get("session_id")
+                    if sid in counts:
+                        counts[sid][key] = d.get("n", 0)
+            except Exception:
+                continue
+        return counts
+    except Exception:
+        return {}
+
+
 @router.get("/peers")
 async def peers(request: Request):
     broker = _get_broker(request)
-    return {"peers": broker.list_all_peers()}
+    peer_list = broker.list_all_peers(_active_profile())
+    session_ids = [p.get("session_id") for p in peer_list if p.get("session_id")]
+    counts = _peer_activity_counts(request, session_ids)
+    for p in peer_list:
+        c = counts.get(p.get("session_id"), {})
+        p["tool_count"] = c.get("tool_count", 0)
+        p["memory_count"] = c.get("memory_count", 0)
+    return {"peers": peer_list}
 
 
 @router.post("/heartbeat")
 async def heartbeat(req: HeartbeatRequest, request: Request):
     broker = _get_broker(request)
-    result = broker.heartbeat(req.peer_id)
+    result = broker.heartbeat(req.peer_id, profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
@@ -177,7 +241,8 @@ async def heartbeat(req: HeartbeatRequest, request: Request):
 @router.post("/summary")
 async def summary(req: SummaryRequest, request: Request):
     broker = _get_broker(request)
-    result = broker.update_summary(req.peer_id, req.summary)
+    result = broker.update_summary(req.peer_id, req.summary,
+                                   profile_id=_active_profile())
     if not result.get("ok"):
         raise HTTPException(404, detail=result.get("error", "peer not found"))
     return result
@@ -189,7 +254,17 @@ async def send(req: SendRequest, request: Request):
     to_target = req.to_peer or req.to  # v3.4.6: accept both field names
     if not to_target:
         raise HTTPException(400, detail="'to' or 'to_peer' required")
-    result = broker.send_message(req.from_peer, to_target, req.content, req.type)
+    # Resolve the tenant on the event loop (the request ContextVar is set here);
+    # a worker thread would not inherit it.
+    profile = _active_profile()
+    # send_message may make a blocking httpx call (up to 10s) when delivering
+    # to a remote peer. Offload to a worker thread so a slow/dead peer network
+    # never stalls the daemon event loop for all other users. The broker opens
+    # a fresh SQLite connection per call, so this is thread-safe.
+    result = await asyncio.to_thread(
+        broker.send_message, req.from_peer, to_target, req.content,
+        req.type, "", profile,
+    )
     if not result.get("ok"):
         status = 413 if "too large" in result.get("error", "") else 404
         raise HTTPException(status, detail=result.get("error", ""))
@@ -199,27 +274,30 @@ async def send(req: SendRequest, request: Request):
 @router.get("/inbox/{peer_id}")
 async def inbox(peer_id: str, request: Request, project_path: str = ""):
     broker = _get_broker(request)
-    return {"messages": broker.get_inbox(peer_id, project_path)}
+    return {"messages": broker.get_inbox(peer_id, project_path,
+                                         profile_id=_active_profile())}
 
 
 @router.post("/inbox/{peer_id}/read")
 async def mark_read(peer_id: str, req: ReadRequest, request: Request):
     broker = _get_broker(request)
-    return broker.mark_read(peer_id, req.message_ids)
+    return broker.mark_read(peer_id, req.message_ids,
+                            profile_id=_active_profile())
 
 
 @router.get("/pending/{peer_id}")
 async def pending(peer_id: str, request: Request, project_path: str = ""):
     """Get pending broadcast/project messages for this peer."""
     broker = _get_broker(request)
-    messages = broker.get_pending(peer_id, project_path)
+    messages = broker.get_pending(peer_id, project_path,
+                                  profile_id=_active_profile())
     return {"messages": messages, "count": len(messages)}
 
 
 @router.get("/state")
 async def state_all(request: Request):
     broker = _get_broker(request)
-    return {"state": broker.get_state()}
+    return {"state": broker.get_state(profile_id=_active_profile())}
 
 
 @router.post("/state")
@@ -228,13 +306,14 @@ async def state_set(req: StateSetRequest, request: 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)
+    return broker.set_state(req.key, req.value, req.set_by,
+                            profile_id=_active_profile())
 
 
 @router.get("/state/{key}")
 async def state_get(key: str, request: Request):
     broker = _get_broker(request)
-    result = broker.get_state_key(key)
+    result = broker.get_state_key(key, profile_id=_active_profile())
     if result is None:
         raise HTTPException(404, detail="key not found")
     return result
@@ -247,16 +326,17 @@ async def lock(req: LockRequest, request: Request):
         raise HTTPException(400, detail="file_path and locked_by required")
     if req.action not in ("acquire", "release", "query"):
         raise HTTPException(400, detail="action must be acquire, release, or query")
-    return broker.lock_action(req.file_path, req.locked_by, req.action)
+    return broker.lock_action(req.file_path, req.locked_by, req.action,
+                              profile_id=_active_profile())
 
 
 @router.get("/events")
 async def events(request: Request):
     broker = _get_broker(request)
-    return {"events": broker.get_events()}
+    return {"events": broker.get_events(profile_id=_active_profile())}
 
 
 @router.get("/status")
 async def status(request: Request):
     broker = _get_broker(request)
-    return broker.get_status()
+    return broker.get_status(profile_id=_active_profile())

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

@@ -71,6 +71,36 @@ async def put_config(body: ConfigUpdateRequest) -> dict[str, Any]:
         raise HTTPException(status_code=500, detail=str(exc))
 
 
+@router.get("/status")
+async def get_status() -> dict[str, Any]:
+    """Concise enabled/disabled summary of each optimize sub-feature (M3).
+
+    REST-convention companion to `slm optimize status` (which reads config
+    locally). Returns a per-feature on/off view, the compression mode, and a
+    top-level `healthy` flag so external pollers have a stable endpoint.
+    """
+    try:
+        from superlocalmemory.optimize.config import get_shared_store
+        cfg = get_shared_store().get()
+        return {
+            "healthy": True,
+            "enabled": cfg.enabled,
+            "features": {
+                "proxy": cfg.proxy_enabled,
+                "cache": cfg.cache_enabled,
+                "compression": cfg.compress_enabled,
+                "semantic_cache": cfg.semantic_enabled,
+            },
+            "compress_mode": cfg.compress_mode,
+            "config_version": cfg.config_version,
+        }
+    except Exception as exc:
+        logger.warning("GET /api/optimize/status failed: %s", exc)
+        # Fail-open: report unhealthy rather than 500 so a poller can
+        # distinguish "daemon up but optimize degraded" from "daemon down".
+        return {"healthy": False, "error": "internal error"}
+
+
 @router.get("/savings")
 async def get_savings() -> dict[str, Any]:
     """Return savings estimates from live metrics + CacheDB.
@@ -91,7 +121,9 @@ async def get_savings() -> dict[str, Any]:
         )
 
         # F-03 fix: use module-level singleton instead of per-request instantiation
-        active_model = getattr(cfg, "active_model", "anthropic")
+        # DASH-V6 fix: attribute may EXIST but be None; getattr default only
+        # covers the missing case, so coerce None -> default to avoid .lower() crash.
+        active_model = getattr(cfg, "active_model", None) or "anthropic"
         # Determine provider from model
         provider = "anthropic"
         for key in ("anthropic", "openai", "gemini"):