superlocalmemory 4.1.13 → 4.1.14

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

@@ -1,3023 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""V3 API endpoints for the SuperLocalMemory dashboard."""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-import os
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import JSONResponse
-from superlocalmemory.core.session_identity import synthetic_session_id
-from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
-from superlocalmemory.core.status_contract import (
-    COUNT_QUERIES,
-    counts_from_sqlite,
-    projection_queue_depth,
-    store_size_mb,
-)
-from superlocalmemory.server.routes.helpers import SLM_VERSION, get_read_connection
-from superlocalmemory.server.route_mutations import authorize_route_mutation
-
-logger = logging.getLogger(__name__)
-
-def _signal_session_id() -> str:
-    """A name for the caller, for matching an outcome back to this recall.
-
-    The agent id the request arrived under, when it arrived under one. Falls
-    back to the workspace, which keeps dashboard and scripted traffic separable
-    from an agent's. Never empty: an unnamed recall leaves no record.
-    """
-    try:
-        from superlocalmemory.mcp.agent_context import get_current_agent_id
-
-        agent = str(get_current_agent_id() or "").strip()
-        if agent:
-            return synthetic_session_id("agent", agent)
-    except Exception:  # noqa: BLE001 -- naming the caller must never fail a read
-        pass
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile
-
-        return synthetic_session_id("api", str(get_active_profile()))
-    except Exception:  # noqa: BLE001
-        return synthetic_session_id("api", "default")
-
-
-router = APIRouter(prefix="/api/v3", tags=["v3"])
-
-
-def _internal_error() -> JSONResponse:
-    """SEC-H-02: log the full traceback server-side, return a generic message.
-
-    Returning ``str(e)`` to the client leaked DB schema (column/constraint
-    names), the data-directory filesystem path, and — for config routes — could
-    surface LLM config internals. Call this only from inside an ``except`` block
-    so ``logger.exception`` captures the active traceback.
-    """
-    logger.exception("v3_api request failed")
-    return JSONResponse({"error": "Internal server error"}, status_code=500)
-
-
-async def _apply_runtime_config(request: Request, config, *, mode_change: bool) -> None:
-    """Persist and hot-swap config only after the daemon transition succeeds."""
-    import asyncio
-
-    authorization = authorize_route_mutation(
-        request,
-        operation="update",
-        source_agent_id="dashboard-config",
-        profile_id=getattr(config, "active_profile", "default"),
-    )
-    from superlocalmemory.server.profile_runtime import reconfigure_daemon_engine
-
-    await asyncio.to_thread(
-        reconfigure_daemon_engine,
-        request.app.state,
-        config,
-        mode_change=mode_change,
-    )
-    authorization.complete()
-
-
-def _require_manage(request: Request) -> None:
-    """Use one explicit authorization boundary for dashboard configuration."""
-    from superlocalmemory.server.rbac_enforce import require_manage
-
-    require_manage(request)
-
-
-def _resolve_profile(request: Request, requested: str = "") -> str:
-    """Resolve a profile override and enforce READ on its actual target."""
-    from superlocalmemory.access.rbac import Permission
-    from superlocalmemory.server.rbac_enforce import require_permission
-    from superlocalmemory.server.routes.helpers import get_active_profile
-
-    if requested and not isinstance(requested, str):
-        raise HTTPException(status_code=422, detail="profile must be a string")
-    profile = requested.strip() if requested else get_active_profile()
-    require_permission(request, Permission.READ, profile=profile)
-    return profile
-
-
-def _resolve_mutation_profile(requested: object) -> str:
-    """Resolve a body-supplied profile without silently coercing bad input."""
-    from superlocalmemory.server.routes.helpers import get_active_profile
-
-    if requested is not None and not isinstance(requested, str):
-        raise HTTPException(status_code=422, detail="profile must be a string")
-    return requested.strip() if requested and requested.strip() else get_active_profile()
-
-
-def _require_manage_for_profile(request: Request, profile: str) -> None:
-    """Enforce MANAGE on the resolved mutation target before any side effect."""
-    from superlocalmemory.server.rbac_enforce import require_manage
-
-    require_manage(request, profile=profile)
-
-
-# ── Dashboard ────────────────────────────────────────────────
-
-@router.get("/dashboard")
-async def dashboard(request: Request):
-    """Dashboard summary: mode, memory count, health score, recent activity."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-        from superlocalmemory.server.profile_runtime import get_profile_runtime
-
-        active_profile = get_profile_runtime(request.app.state).snapshot.profile_id
-
-        # Read stats directly from SQLite (dashboard doesn't load engine)
-        memory_count = 0
-        counts = dict.fromkeys(COUNT_QUERIES, 0)
-        queue_depth = 0
-        db_path = config.base_dir / "memory.db"
-        if db_path.exists():
-            try:
-                conn = get_read_connection(db_path)
-                counts = counts_from_sqlite(conn, active_profile)
-                queue_depth = projection_queue_depth(conn)
-                cursor = conn.cursor()
-                try:
-                    try:
-                        cursor.execute(
-                            "SELECT COUNT(*) FROM memories WHERE profile_id = ?",
-                            (active_profile,),
-                        )
-                    except Exception:
-                        cursor.execute(
-                            "SELECT COUNT(*) FROM memories WHERE profile = ?",
-                            (active_profile,),
-                        )
-                    memory_count = cursor.fetchone()[0]
-                except Exception:
-                    pass
-                conn.close()
-            except Exception:
-                pass
-
-        from superlocalmemory.core.modes import dashboard_mode_fields
-
-        # Mode record is the single source of truth for locality claims (F-03).
-        payload = {
-            "mode": config.mode.value,
-            "mode_name": {"a": "Local Guardian", "b": "Smart Local", "c": "Full Power"}.get(config.mode.value, "Unknown"),
-            "provider": config.llm.provider or "none",
-            "model": config.llm.model or "",
-            "memory_count": memory_count,
-            "profile": active_profile,
-            "base_dir": str(config.base_dir),
-            "version": SLM_VERSION,
-            # The counts and the store's own address were missing here while
-            # every other status surface carried them, so the one surface a
-            # person actually looks at could not answer "is the graph healthy".
-            "db_path": str(db_path),
-            "db_size_mb": store_size_mb(db_path),
-            "profile_generation": get_profile_runtime(
-                request.app.state,
-            ).snapshot.generation,
-            # Facts stored but not yet in the graph and vector projections. A
-            # number that does not fall is a projection that has stopped
-            # keeping up, which is otherwise invisible: nothing errors, the
-            # memory is safely in SQLite, and recall just quietly gets worse.
-            "projection_queue_depth": queue_depth,
-            **counts,
-        }
-        payload.update(dashboard_mode_fields(config.mode))
-        return payload
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Mode ─────────────────────────────────────────────────────
-
-@router.get("/mode")
-async def get_mode(request: Request):
-    """Get current mode, provider, model — single source of truth for UI."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        from urllib.parse import urlparse
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-        current = config.mode.value
-        # SEC-L-01: expose only the endpoint HOST, not the full URL. A full
-        # api_base (e.g. an internal Azure OpenAI deployment path) leaks
-        # infrastructure topology to non-admin (viewer) users.
-        _api_base = config.llm.api_base or ""
-        _endpoint_host = urlparse(_api_base).netloc if _api_base else ""
-        return {
-            "mode": current,
-            "provider": config.llm.provider or "none",
-            "model": config.llm.model or "",
-            "has_key": bool(config.llm.api_key),
-            "endpoint": _endpoint_host,
-            "capabilities": {
-                "llm_available": bool(config.llm.provider),
-                "cross_encoder": config.retrieval.use_cross_encoder if hasattr(config, 'retrieval') else False,
-            },
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-@router.put("/mode")
-async def set_mode(request: Request):
-    """Switch operating mode. Body: {"mode": "a"|"b"|"c"}"""
-    # SEC-H-01: mode switch reconfigures the whole engine — admin-only (MANAGE)
-    # on top of machine auth. Owner keeps MANAGE; personal mode unaffected.
-    from superlocalmemory.server.rbac_enforce import require_manage
-    require_manage(request)
-    try:
-        body = await request.json()
-        new_mode = body.get("mode", "").lower()
-        if new_mode not in ("a", "b", "c"):
-            return JSONResponse({"error": "Invalid mode. Use a, b, or c."}, status_code=400)
-
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.storage.models import Mode
-        from superlocalmemory.server.routes.helpers import log_mode_change
-        old_config = SLMConfig.load()
-        old_mode = old_config.mode.value
-
-        # Safety: a bare ``{mode:"c"}`` body (e.g., a stray dashboard button
-        # click) used to silently auto-default the model to
-        # ``anthropic/claude-sonnet-4`` with no API key, writing phantom state
-        # into config.json. Refuse that path — Mode C requires explicit
-        # provider+key via POST /api/v3/mode/set.
-        if new_mode == "c" and not old_config.llm.api_key:
-            return JSONResponse(
-                {
-                    "error": (
-                        "Mode C requires a cloud API key. "
-                        "Configure provider + key in Settings → Step 2 "
-                        "(uses POST /api/v3/mode/set)."
-                    ),
-                    "code": "mode_c_requires_api_key",
-                },
-                status_code=400,
-            )
-
-        # Apply new mode's structural presets (retrieval, math, channel_weights)
-        # by building a fresh template, then graft them onto the loaded config so
-        # all user-tuned blocks (forgetting, injection, consolidation, scope, …)
-        # are preserved across the mode switch.
-        _template = SLMConfig.for_mode(Mode(new_mode))
-        old_config.mode = Mode(new_mode)
-        old_config.retrieval = _template.retrieval
-        old_config.math = _template.math
-        old_config.channel_weights = _template.channel_weights
-        new_config = old_config
-
-        await _apply_runtime_config(request, new_config, mode_change=True)
-
-        # Audit the change before we lose context — proves who/when/what.
-        # Captures the phantom-write case where `for_mode(C)` auto-defaults
-        # the model to "anthropic/claude-sonnet-4" (see core/config.py).
-        log_mode_change(
-            old_mode, new_mode,
-            provider=new_config.llm.provider,
-            model=new_config.llm.model,
-            source="PUT /api/v3/mode",
-        )
-
-        # V3.3: Check if embedding model changed — flag for re-indexing
-        needs_reindex = (
-            old_config.embedding.provider != new_config.embedding.provider
-            or old_config.embedding.model_name != new_config.embedding.model_name
-        )
-
-        return {
-            "success": True,
-            "mode": new_mode,
-            "needs_reindex": needs_reindex,
-            "message": "Embedding re-indexing will run on next recall." if needs_reindex else "",
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-def apply_settings_update(config: "SLMConfig", payload: dict) -> "SLMConfig":
-    """Credential-safe LLM config update for the settings dashboard (fixes #119).
-
-    This is the SINGLE authoritative place where incoming dashboard save payloads
-    are merged onto the stored config.  The POST /api/v3/mode/set handler calls
-    this function after its HTTP-layer concerns (SSRF guard, auth) are settled,
-    so the test suite (test_acceptance_core.py::P3) tests real product
-    behaviour — not a reimplementation.
-
-    SEC-L-01 PRESERVED:
-      The GET /mode route returns only ``urlparse(api_base).netloc`` (the host),
-      never the full URL.  When the UI echoes that value back on save,
-      apply_settings_update detects the scheme-less netloc and silently restores
-      the stored full URL (scheme + path).  This means the server-side logic
-      internally reads the stored URL but NEVER returns it to callers — viewer
-      users remain unable to discover the full endpoint topology.
-
-    Credential semantics:
-      api_key  blank/omitted   →  UNCHANGED  (browsers never repopulate pw fields)
-      api_key  non-blank       →  applied
-      clear_api_key = True     →  explicit "" (deliberate wipe — only way to clear)
-
-      endpoint  absent/empty   →  UNCHANGED
-      endpoint  == stored netloc (no scheme "://")  →  UNCHANGED (redacted echo)
-      endpoint  with "://"     →  applied
-      clear_base_url = True    →  explicit "" (deliberate wipe)
-
-    Security rule:  if the destination provider or endpoint genuinely changes AND
-    no new key was supplied, the stored key is cleared to prevent accidental
-    credential reuse across providers.  An explicit clear_api_key=True is
-    always honoured regardless.
-
-    NEVER logs api_key.
-    """
-    import dataclasses as _dc
-    from urllib.parse import urlparse, urlsplit, urlunsplit
-
-    stored = config.llm
-    stored_key: str = stored.api_key
-    stored_base: str = stored.api_base or ""
-
-    # ── endpoint ─────────────────────────────────────────────────────────────
-    raw_endpoint: str = (payload.get("endpoint") or payload.get("base_url") or "").strip()
-    clear_endpoint: bool = payload.get("clear_base_url") is True
-
-    if clear_endpoint:
-        new_base = ""
-        endpoint_changed = bool(stored_base)
-    elif not raw_endpoint:
-        # Nothing supplied — keep stored URL intact.
-        new_base = stored_base
-        endpoint_changed = False
-    else:
-        # Detect the SEC-L-01 redacted echo: GET /mode returns
-        # urlparse(api_base).netloc (host only, no scheme, no path).  If the
-        # client sent that exact string back, it did NOT change the endpoint —
-        # restore the full stored URL.  We compare the raw string directly to
-        # stored_netloc so that hosts with ports ("api.host.com:443") also match.
-        stored_netloc: str = urlparse(stored_base).netloc if stored_base else ""
-        is_redacted_echo: bool = bool(stored_netloc) and (raw_endpoint == stored_netloc)
-
-        if is_redacted_echo:
-            new_base = stored_base
-            endpoint_changed = False
-        else:
-            new_base = raw_endpoint
-            # Canonical comparison (strip trailing slash, normalise scheme/host
-            # case) so a harmless trailing-slash difference does not clear the key.
-            def _canonical(u: str) -> str:
-                p = urlsplit(u)
-                return urlunsplit((
-                    p.scheme.lower(), p.netloc.lower(),
-                    p.path.rstrip("/"), p.query, "",
-                ))
-            endpoint_changed = _canonical(new_base) != _canonical(stored_base)
-
-    # ── provider ─────────────────────────────────────────────────────────────
-    raw_provider: str = (payload.get("provider") or "").strip()
-    if raw_provider == "none":
-        new_provider = ""      # "none" sentinel means "clear provider"
-    elif raw_provider:
-        new_provider = raw_provider
-    else:
-        new_provider = stored.provider or ""
-
-    provider_changed: bool = new_provider != (stored.provider or "")
-
-    # ── api_key ───────────────────────────────────────────────────────────────
-    # Evaluated AFTER endpoint/provider so we know whether the destination changed.
-    raw_key: str = (payload.get("api_key") or "").strip()
-    clear_key: bool = payload.get("clear_api_key") is True
-    destination_changed: bool = provider_changed or endpoint_changed
-
-    if clear_key:
-        new_key = ""           # explicit user wipe
-    elif raw_key:
-        new_key = raw_key      # user supplied a replacement key
-    elif destination_changed:
-        # Security: destination changed but no new key → clear to prevent
-        # the stored credential from being silently redirected to a new
-        # provider or endpoint the user may not own.
-        new_key = ""
-    else:
-        # Blank key + same destination = browser did not repopulate the
-        # password field.  Preserve the stored key verbatim.
-        new_key = stored_key
-
-    # ── model ────────────────────────────────────────────────────────────────
-    raw_model: str = (payload.get("model") or "").strip()
-    new_model: str = raw_model if raw_model else (stored.model or "")
-
-    # ── apply ─────────────────────────────────────────────────────────────────
-    # dataclasses.replace preserves temperature / max_tokens / timeout_seconds.
-    # Assigning to config.llm works because SLMConfig is not frozen.
-    # NEVER include new_key in any log call.
-    config.llm = _dc.replace(
-        stored,
-        provider=new_provider,
-        model=new_model,
-        api_key=new_key,
-        api_base=new_base,
-    )
-    return config
-
-
-@router.post("/mode/set")
-async def set_full_config(request: Request):
-    """Save mode + provider + model + API key together.
-
-    V3.4.24: Also accepts embedding_* fields for custom embedding endpoints.
-    """
-    # SEC-H-01: sets the LLM provider + API key for the whole engine — admin-only.
-    from superlocalmemory.server.rbac_enforce import require_manage
-    require_manage(request)
-    try:
-        body = await request.json()
-        if not isinstance(body, dict):
-            return JSONResponse({"error": "Request body must be a JSON object"}, status_code=400)
-        from superlocalmemory.core.config import SLMConfig, EmbeddingConfig
-        from superlocalmemory.storage.models import Mode
-        from superlocalmemory.server.routes.helpers import log_mode_change
-
-        config = SLMConfig.load()
-        old_mode = config.mode.value
-
-        def _nonblank(name: str) -> str | None:
-            value = body.get(name)
-            if value is None:
-                return None
-            if not isinstance(value, str):
-                raise ValueError(f"{name} must be a string")
-            return value.strip() or None
-
-        new_mode = (_nonblank("mode") or config.mode.value).lower()
-        provider_input = _nonblank("provider")
-        model_input = _nonblank("model")
-        api_key_input = _nonblank("api_key")
-        base_url_input = _nonblank("base_url")
-        endpoint_input = _nonblank("endpoint")
-        clear_api_key = body.get("clear_api_key") is True
-        clear_base_url = body.get("clear_base_url") is True
-
-        if clear_api_key and api_key_input:
-            return JSONResponse(
-                {"error": "api_key cannot be replaced and cleared together"},
-                status_code=400,
-            )
-        if clear_base_url and (base_url_input or endpoint_input):
-            return JSONResponse(
-                {"error": "base_url cannot be replaced and cleared together"},
-                status_code=400,
-            )
-        if base_url_input and endpoint_input and base_url_input != endpoint_input:
-            return JSONResponse(
-                {"error": "base_url and endpoint must match when both are supplied"},
-                status_code=400,
-            )
-
-        if new_mode not in ("a", "b", "c"):
-            return JSONResponse({"error": "Invalid mode"}, status_code=400)
-
-        # Resolve the effective endpoint value before SSRF validation.
-        # Only the Ollama default injection happens here; the fallback to the
-        # stored URL (and redacted-echo detection) live inside
-        # apply_settings_update so that the P3 test exercises
-        # the same code path as the HTTP handler — not a reimplementation.
-        _raw_ep: str = "" if clear_base_url else (base_url_input or endpoint_input or "")
-        if (
-            not _raw_ep
-            and provider_input == "ollama"
-            and config.llm.provider != "ollama"
-            and not clear_base_url
-        ):
-            _raw_ep = "http://localhost:11434"
-
-        # SSRF guard — fires only for genuinely new egress destinations.
-        # Redacted echoes (the netloc-only string GET /mode returns per
-        # SEC-L-01) are NOT outbound targets; they will be silently replaced
-        # with the stored full URL by apply_settings_update.
-        if _raw_ep and (base_url_input is not None or endpoint_input is not None):
-            from urllib.parse import urlparse as _up
-            _stored_nl: str = _up(config.llm.api_base or "").netloc
-            _is_redacted_echo: bool = bool(_stored_nl) and (_raw_ep == _stored_nl)
-            if not _is_redacted_echo:
-                client = getattr(request, "client", None)
-                endpoint_error = _validate_provider_url(
-                    _raw_ep, getattr(client, "host", "") if client else ""
-                )
-                if endpoint_error:
-                    return JSONResponse({"error": endpoint_error}, status_code=400)
-
-        # Build the normalised body for apply_settings_update.  Inject the
-        # resolved endpoint (Ollama default when applicable) so that the
-        # credential-safe logic sees the approved value.  Consolidate
-        # base_url → endpoint to keep apply_settings_update's lookup simple.
-        _apply_body: dict = dict(body)
-        if _raw_ep or clear_base_url:
-            _apply_body["endpoint"] = _raw_ep
-            _apply_body.pop("base_url", None)
-
-        # Credential-safe LLM update.  All field presence, preservation, and
-        # security-clearing rules live here.  Other config blocks (forgetting,
-        # injection, retrieval, math, consolidation, scope, …) are preserved
-        # because we loaded the full existing config at the top of this handler.
-        config = apply_settings_update(config, _apply_body)
-
-        # Mode switch — happens after LLM update so the correct provider/key
-        # is already in place when the runtime engine is reconfigured.
-        config.mode = Mode(new_mode)
-
-        # Update embedding only when the dashboard explicitly sent those fields;
-        # absence means "leave it alone" (AIDEV-86 / broader fix).
-        _emb_fields = ("embedding_provider", "embedding_endpoint", "embedding_key",
-                       "embedding_model", "embedding_dimension")
-        if any(k in body for k in _emb_fields):
-            _old_emb = config.embedding
-            _new_provider = body.get("embedding_provider", "")
-            _new_model = body.get("embedding_model", "")
-            _new_dim = int(body.get("embedding_dimension", 0) or 0)
-            # The same range the other save route enforces. Without it a
-            # dashboard save with no dimension field stored a width of zero.
-            if _new_dim and not (64 <= _new_dim <= 8192):
-                return JSONResponse(
-                    {"error": f"Dimension must be 64-8192, got {_new_dim}"},
-                    status_code=400,
-                )
-            # The SECOND way to change the embedding model, and it was
-            # unguarded. Switching mode from the dashboard carries the embedding
-            # fields, so a width that the store cannot hold arrived here
-            # untouched while the other route refused it — one door bolted, the
-            # other open.
-            if not bool(body.get("force")):
-                _refusal = _refuse_incompatible_embedding(
-                    config, config.embedding, _new_model, _new_dim,
-                    new_provider=_new_provider,
-                )
-                if _refusal is not None:
-                    return _refusal
-            config.embedding = EmbeddingConfig(
-                provider=_new_provider,
-                api_endpoint=body.get("embedding_endpoint", ""),
-                api_key=body.get("embedding_key", ""),
-                model_name=_new_model,
-                dimension=_new_dim or _old_emb.dimension,
-                # Not naming these reset them to defaults, so every embedding
-                # save from the dashboard silently put the local model back to
-                # whatever ships — the exact defect the other route had.
-                ollama_model=(
-                    _new_model if _new_provider == "ollama" and _new_model
-                    else _old_emb.ollama_model
-                ),
-                ollama_base_url=_old_emb.ollama_base_url,
-                api_version=_old_emb.api_version,
-                deployment_name=_old_emb.deployment_name,
-            )
-
-        # When the mode actually changed, apply the new mode's structural presets
-        # (retrieval topology, math thresholds, channel weights) so the user gets
-        # the right runtime behaviour for their chosen mode.
-        if new_mode != old_mode:
-            _template = SLMConfig.for_mode(Mode(new_mode))
-            config.retrieval = _template.retrieval
-            config.math = _template.math
-            config.channel_weights = _template.channel_weights
-
-        # v3.6.12 (settings-1): mode_change=True is required to persist the new
-        # mode — save() without it hits a guard that preserves the old mode.
-        await _apply_runtime_config(request, config, mode_change=True)
-
-        log_mode_change(
-            old_mode, new_mode,
-            provider=config.llm.provider,
-            model=config.llm.model,
-            source="POST /api/v3/mode/set",
-        )
-
-        # Recycle only out-of-process fallbacks; the resident daemon engine was
-        # already acknowledged and hot-swapped by _apply_runtime_config().
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            WorkerPool.shared().shutdown()
-        except Exception:
-            pass
-
-        return {
-            "success": True,
-            "mode": new_mode,
-            "provider": config.llm.provider or "none",
-            "model": config.llm.model,
-            "embedding_provider": config.embedding.provider,
-            "embedding_model": config.embedding.model_name,
-            "embedding_dimension": config.embedding.dimension,
-        }
-    except ValueError as exc:
-        return JSONResponse({"error": str(exc)}, status_code=400)
-    except Exception as e:
-        return _internal_error()
-
-
-# ── V3.4.24: Embedding Configuration ────────────────────────────────
-
-@router.get("/embedding/config")
-async def get_embedding_config(request: Request):
-    """Return current embedding configuration."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        # The daemon may already be running a freshly hot-swapped config while
-        # a profile update is still being persisted.  The dashboard must show
-        # that live truth, never silently replace it with disk defaults.
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-        emb = config.embedding
-        return {
-            "provider": emb.provider,
-            "model_name": emb.model_name,
-            "dimension": emb.dimension,
-            "api_endpoint": emb.api_endpoint,
-            "has_key": bool(emb.api_key),
-            "is_openai_compatible": emb.is_openai_compatible,
-            "mode": config.mode.value,
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-def _refuse_incompatible_embedding(
-    config, old_emb, new_model, new_dim, new_provider=None,
-):
-    """None when the change is safe, otherwise the 409 to return instead.
-
-    Fail-open on anything it cannot determine: a store with no vectors yet, a
-    model server that is not running, an unreadable database. Refusing on
-    "I could not tell" would block a legitimate first-time setup, and the
-    dimension a caller declares is still checked against the store either way.
-    """
-    from fastapi.responses import JSONResponse as _JSON
-
-    try:
-        from superlocalmemory.core.ollama_validator import (
-            EMBEDDING,
-            stored_embedding_dimension,
-            validate_ollama_model,
-        )
-
-        db_path = Path(config.base_dir) / "memory.db"
-        stored = stored_embedding_dimension(db_path)
-        if stored is None:
-            return None
-
-        # The provider being SAVED, falling back to the current one when the
-        # caller is not changing it. Reading only the current provider meant
-        # that SWITCHING to a local model never probed at all — and switching
-        # is exactly when the width changes.
-        effective_provider = (
-            new_provider
-            if new_provider is not None
-            else getattr(old_emb, "provider", "")
-        )
-        measured = None
-        if effective_provider == "ollama" or getattr(old_emb, "provider", "") == "ollama":
-            # The model being SAVED, not the one already configured. Probing the
-            # old one always matched the stored width and therefore always
-            # allowed the change — the guard measured the thing it was not
-            # protecting against.
-            probe = validate_ollama_model(
-                new_model or getattr(old_emb, "ollama_model", ""),
-                EMBEDDING,
-                base_url=getattr(old_emb, "ollama_base_url", "")
-                or "http://localhost:11434",
-            )
-            measured = probe.dimension if probe.ok else None
-
-        declared = int(new_dim or 0)
-        if measured is None and declared <= 0:
-            # Nothing to compare: the server could not be asked and the caller
-            # named no width. Allowing is the fail-open the first-time setup
-            # needs; the other route's probe still guards the common path.
-            return None
-        effective = measured if measured is not None else declared
-        if effective == stored:
-            return None
-
-        return _JSON(
-            {
-                "error": "embedding_width_mismatch",
-                "stored_dimension": stored,
-                "requested_dimension": effective,
-                "model_name": new_model,
-                "detail": (
-                    f"{new_model} produces {effective}-dimensional vectors and "
-                    f"this store holds {stored}-dimensional ones. Vectors of "
-                    f"different widths cannot be compared, so every memory "
-                    f"already stored would become unfindable by meaning. "
-                    f"Rebuild them first with: slm db migrate — or resend with "
-                    f"force=true if they have already been rebuilt."
-                ),
-            },
-            status_code=409,
-        )
-    except Exception:  # noqa: BLE001 - never block a save on the check failing
-        logger.exception("embedding width pre-check failed; allowing the save")
-        return None
-
-
-@router.put("/embedding/config")
-async def set_embedding_config(request: Request):
-    """Update embedding configuration independently of mode switch."""
-    # SEC-H-01: swapping the embedding provider/key affects all recall — admin-only.
-    from superlocalmemory.server.rbac_enforce import require_manage
-    require_manage(request)
-    try:
-        body = await request.json()
-        from superlocalmemory.core.config import SLMConfig, EmbeddingConfig
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-
-        new_provider = body.get("provider", config.embedding.provider)
-        new_model = body.get("model_name", config.embedding.model_name)
-        new_dim = int(body.get("dimension", config.embedding.dimension) or 768)
-        if not (64 <= new_dim <= 8192):
-            return JSONResponse({"error": f"Dimension must be 64-8192, got {new_dim}"}, status_code=400)
-        new_endpoint = body.get("api_endpoint", config.embedding.api_endpoint)
-        new_key = body.get("api_key", config.embedding.api_key)
-
-        old_emb = config.embedding
-
-        # A width that disagrees with what the store already holds is refused
-        # here, at the moment of writing, not merely offered as a check the
-        # caller may or may not have run. Vectors of different widths cannot be
-        # compared, so the store would keep answering similarity questions and
-        # every answer would be noise. ``force=true`` is the escape hatch for
-        # somebody who has already re-embedded.
-        if not bool(body.get("force")):
-            refusal = _refuse_incompatible_embedding(
-                config, old_emb, new_model, new_dim, new_provider=new_provider,
-            )
-            if refusal is not None:
-                return refusal
-
-        config.embedding = EmbeddingConfig(
-            model_name=new_model,
-            dimension=new_dim,
-            provider=new_provider,
-            api_endpoint=new_endpoint,
-            api_key=new_key,
-            # In Ollama mode the embedder resolves its model from
-            # ``ollama_model``, so keeping the old value here made a rename a
-            # no-op that still answered "success". A caller naming a model gets
-            # that model.
-            ollama_model=(
-                new_model if new_provider == "ollama" and new_model
-                else old_emb.ollama_model
-            ),
-            ollama_base_url=old_emb.ollama_base_url,
-            api_version=old_emb.api_version,
-            deployment_name=old_emb.deployment_name,
-        )
-        await _apply_runtime_config(request, config, mode_change=False)
-
-        needs_reindex = (
-            old_emb.provider != new_provider
-            or old_emb.model_name != new_model
-            or old_emb.dimension != new_dim
-        )
-
-        # Kill workers so next request uses new config
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            WorkerPool.shared().shutdown()
-        except Exception:
-            pass
-        return {
-            "success": True,
-            "provider": new_provider,
-            "model_name": new_model,
-            "dimension": new_dim,
-            "needs_reindex": needs_reindex,
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-@router.get("/scope/config")
-async def get_scope_config(request: Request):
-    """Return runtime multi-scope defaults used by daemon writes and recalls."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-        return {"success": True, **config.scope.as_dict()}
-    except Exception as exc:
-        return _internal_error()
-
-
-@router.put("/scope/config")
-async def set_scope_config(request: Request):
-    """Validate, persist, and hot-apply explicit multi-scope defaults."""
-    # SEC-H-01: scope defaults govern cross-profile recall visibility — admin-only.
-    from superlocalmemory.server.rbac_enforce import require_manage
-    require_manage(request)
-    try:
-        body = await request.json()
-        from superlocalmemory.core.config import SLMConfig, ScopeConfig
-
-        config = SLMConfig.load()
-        current = config.scope
-        default_scope = body.get("default_scope", current.default_scope)
-        if default_scope not in {"personal", "shared", "global"}:
-            return JSONResponse(
-                {"error": "default_scope must be personal, shared, or global"},
-                status_code=400,
-            )
-        include_global = body.get(
-            "recall_include_global", current.recall_include_global,
-        )
-        include_shared = body.get(
-            "recall_include_shared", current.recall_include_shared,
-        )
-        if not isinstance(include_global, bool) or not isinstance(include_shared, bool):
-            return JSONResponse(
-                {"error": "recall scope flags must be booleans"},
-                status_code=400,
-            )
-        config.scope = ScopeConfig(
-            default_scope=default_scope,
-            recall_include_global=include_global,
-            recall_include_shared=include_shared,
-        )
-        await _apply_runtime_config(request, config, mode_change=False)
-        return {"success": True, **config.scope.as_dict()}
-    except Exception as exc:
-        return _internal_error()
-
-
-@router.post("/embedding/test")
-async def test_embedding_endpoint(request: Request):
-    """Test connectivity to a custom embedding endpoint."""
-    _require_manage(request)
-    try:
-        import httpx
-        body = await request.json()
-        endpoint = body.get("api_endpoint", "").rstrip("/")
-        model = body.get("model_name", "test")
-        api_key = body.get("api_key", "")
-
-        if not endpoint:
-            return JSONResponse({"error": "No endpoint provided"}, status_code=400)
-
-        client_host = request.client.host if request.client else ""
-        error = _validate_provider_url(endpoint, client_host)
-        if error:
-            return JSONResponse({"error": error}, status_code=400)
-
-        if not endpoint.endswith("/embeddings"):
-            endpoint = f"{endpoint}/embeddings"
-
-        headers = {"Content-Type": "application/json"}
-        if api_key:
-            headers["Authorization"] = f"Bearer {api_key}"
-
-        payload = {"input": ["test embedding connection"], "model": model}
-
-        with httpx.Client(timeout=httpx.Timeout(15.0)) as client:
-            resp = client.post(endpoint, headers=headers, json=payload)
-            resp.raise_for_status()
-            data = resp.json()
-            emb_data = data.get("data", [])
-            if emb_data:
-                dim = len(emb_data[0].get("embedding", []))
-                return {
-                    "success": True,
-                    "message": f"Connected! Dimension: {dim}",
-                    "dimension": dim,
-                }
-            return {"success": False, "error": "No embedding data returned"}
-    except httpx.HTTPStatusError as e:
-        return {"success": False, "error": f"HTTP {e.response.status_code}"}
-    except httpx.ConnectError:
-        return {"success": False, "error": "Cannot reach the embedding server. Is it running?"}
-    except httpx.TimeoutException:
-        return {"success": False, "error": "Connection timed out after 15 seconds."}
-    except Exception as e:
-        return {"success": False, "error": type(e).__name__}
-
-
-@router.get("/embed/ping")
-async def embed_ping():
-    """V3.5.9: Liveness probe for McpEmbedderProxy. Returns 200 when daemon
-    embedder is ready so the proxy knows the daemon is reachable."""
-    try:
-        from .helpers import get_engine_lazy
-        # We just need to confirm the route is alive — engine check is optional
-        return {"ok": True}
-    except Exception:
-        logger.exception("embedder liveness probe failed")
-        return JSONResponse({"ok": False, "error": "Internal server error"}, status_code=503)
-
-
-@router.post("/embed")
-async def embed_texts(request: Request):
-    """V3.5.9: Embed texts via daemon's FULL engine for McpEmbedderProxy.
-
-    MCP processes run LIGHT engines (no ONNX worker). This endpoint lets them
-    delegate embed_batch() to the daemon's single real embedder — one ONNX
-    worker total across all sessions (fixes PR #30 NULL embedder bug).
-    """
-    import asyncio
-    try:
-        body = await request.json()
-        texts = body.get("texts", [])
-        if not texts:
-            return {"embeddings": []}
-
-        from .helpers import get_engine_lazy
-        engine = get_engine_lazy(request.app.state)
-        if engine is None or engine._embedder is None:
-            return JSONResponse(
-                {"error": "Embedder not available in daemon"},
-                status_code=503,
-            )
-
-        loop = asyncio.get_event_loop()
-        embeddings = await loop.run_in_executor(
-            None,
-            lambda: engine._embedder.embed_batch(texts),
-        )
-        return {"embeddings": embeddings}
-    except Exception as e:
-        return _internal_error()
-
-
-def _validate_provider_url(url: str, client_host: str) -> str | None:
-    """SSRF guard for outbound provider-test fetches (v3.6.12 ssrf-1).
-
-    Returns an error string if ``url`` is unsafe, else None. ALWAYS blocks
-    non-http(s) and cloud-metadata hosts. A LOOPBACK caller (the local
-    dashboard) may legitimately test local/LAN LLM endpoints, so private IPs
-    are allowed for it. A NON-loopback caller may not make the server fetch
-    private/loopback/link-local/reserved targets — that is the SSRF abuse.
-    """
-    from superlocalmemory.server.egress_policy import (
-        EgressActor,
-        EgressVerdict,
-        validate_egress_url,
-    )
-    from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
-
-    is_local = _is_loopback_host(client_host)
-    # SLM_REMOTE residue (#40): an allowlisted LAN dashboard is trusted exactly
-    # like the loopback one and may probe its own LAN LLM endpoint. This does
-    # NOT relax the SSRF guard for arbitrary remote callers —
-    # is_lan_client_allowed is False unless remote mode is ON *and* the client
-    # IP is in SLM_MCP_ALLOWED_HOSTS.
-    is_lan = False
-    try:
-        from superlocalmemory.core.remote_mode import is_lan_client_allowed
-        is_lan = bool(is_lan_client_allowed(client_host))
-    except Exception:  # pragma: no cover — defensive, never weaken on import error
-        is_lan = False
-
-    result = validate_egress_url(
-        url, EgressActor(is_local=is_local, is_lan=is_lan)
-    )
-
-    if result.verdict is EgressVerdict.ALLOW:
-        return None
-    if result.verdict is EgressVerdict.DENY_SCHEME:
-        return "Only http/https endpoints are supported"
-    if result.verdict is EgressVerdict.DENY_METADATA:
-        return "Cloud metadata endpoints are not allowed"
-    if result.verdict in (
-        EgressVerdict.DENY_CREDENTIALS,
-        EgressVerdict.DENY_FRAGMENT,
-    ):
-        return "Endpoint URL must not embed credentials or fragments"
-    if result.verdict is EgressVerdict.DENY_DNS_FAILURE:
-        return "Endpoint host could not be resolved"
-    # DENY_PRIVATE / DENY_MIXED_DNS / DENY_HOST
-    return "Internal/private endpoints are not allowed from a remote client"
-
-
-@router.post("/provider/test")
-async def test_provider(request: Request):
-    """Test connectivity to an LLM provider."""
-    try:
-        import httpx
-        body = await request.json()
-        provider = body.get("provider", "")
-        model = body.get("model", "")
-        api_key = body.get("api_key", "")
-        _client_host = request.client.host if request.client else ""
-
-        if provider == "ollama":
-            endpoint = body.get("endpoint", "http://localhost:11434")
-            _err = _validate_provider_url(endpoint, _client_host)
-            if _err:
-                return {"success": False, "error": _err}
-            with httpx.Client(timeout=httpx.Timeout(5.0)) as c:
-                resp = c.get(f"{endpoint}/api/tags")
-                resp.raise_for_status()
-                models = [m["name"] for m in resp.json().get("models", [])]
-                # Match either exact name or base name (strip ":tag" suffix on both sides)
-                model_base = model.split(":")[0] if model else ""
-                found = any(m == model or m.split(":")[0] == model_base for m in models) if model else len(models) > 0
-                return {
-                    "success": found,
-                    "message": f"Ollama OK, {len(models)} models" + (f", '{model}' available" if found and model else ""),
-                }
-
-        if provider == "openrouter":
-            if not api_key:
-                api_key = os.environ.get("OPENROUTER_API_KEY", "")
-            if not api_key:
-                return {"success": False, "error": "API key required"}
-            with httpx.Client(timeout=httpx.Timeout(10.0)) as c:
-                resp = c.get("https://openrouter.ai/api/v1/models", headers={"Authorization": f"Bearer {api_key}"})
-                resp.raise_for_status()
-                return {"success": True, "message": "OpenRouter connected, key valid"}
-
-        if provider == "openai":
-            # V3.5.9: custom/local endpoint — api_key is optional (llama.cpp, LM Studio etc.)
-            custom_endpoint = body.get("base_url", "").strip() or body.get("endpoint", "").strip()
-            if custom_endpoint:
-                _err = _validate_provider_url(custom_endpoint, _client_host)
-                if _err:
-                    return {"success": False, "error": _err}
-                headers_test = {"Content-Type": "application/json"}
-                if api_key:
-                    headers_test["Authorization"] = f"Bearer {api_key}"
-                base = custom_endpoint.rstrip("/")
-                if not base.endswith("chat/completions"):
-                    base = f"{base}/chat/completions"
-                with httpx.Client(timeout=httpx.Timeout(10.0)) as c:
-                    # Probe with a minimal chat request (models list not universal on local servers)
-                    probe = {"model": body.get("model", "test"), "messages": [{"role": "user", "content": "hi"}], "max_tokens": 1}
-                    resp = c.post(base, headers=headers_test, json=probe)
-                    if resp.status_code in (200, 400, 422):
-                        return {"success": True, "message": f"Custom endpoint reachable (HTTP {resp.status_code})"}
-                    resp.raise_for_status()
-                    return {"success": True, "message": "Custom OpenAI-compatible endpoint connected"}
-            if not api_key:
-                return {"success": False, "error": "API key required for official OpenAI endpoint"}
-            with httpx.Client(timeout=httpx.Timeout(10.0)) as c:
-                resp = c.get("https://api.openai.com/v1/models", headers={"Authorization": f"Bearer {api_key}"})
-                resp.raise_for_status()
-                return {"success": True, "message": "OpenAI connected, key valid"}
-
-        if provider == "anthropic":
-            if not api_key:
-                return {"success": False, "error": "API key required"}
-            # Anthropic doesn't have a models list endpoint, just verify key format
-            if api_key.startswith("sk-ant-"):
-                return {"success": True, "message": "Anthropic key format valid"}
-            return {"success": False, "error": "Key should start with sk-ant-"}
-
-        return {"success": False, "error": f"Unknown provider: {provider}"}
-    except httpx.ConnectError:
-        return {"success": False, "error": "Cannot connect — is the service running?"}
-    except httpx.HTTPStatusError as e:
-        return {"success": False, "error": f"HTTP {e.response.status_code}: Invalid key or endpoint"}
-    except Exception as e:
-        logger.exception("verify_key failed")
-        return {"success": False, "error": "internal error"}
-
-
-@router.get("/ollama/status")
-async def ollama_status():
-    """Check if Ollama is running and list available models."""
-    try:
-        import httpx
-        with httpx.Client(timeout=httpx.Timeout(5.0)) as client:
-            resp = client.get("http://localhost:11434/api/tags")
-            resp.raise_for_status()
-            data = resp.json()
-            models = [
-                {"name": m["name"], "size": m.get("size", 0)}
-                for m in data.get("models", [])
-            ]
-            return {"running": True, "models": models, "count": len(models)}
-    except Exception:
-        return {"running": False, "models": [], "count": 0}
-
-
-# ── Provider ─────────────────────────────────────────────────
-
-@router.get("/providers")
-async def list_providers():
-    """List available LLM providers with presets."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        return {"providers": SLMConfig.provider_presets()}
-    except Exception as exc:
-        logger.exception("list_providers failed")
-        return {"error": "could not load provider list", "providers": []}
-
-
-@router.get("/provider")
-async def get_provider():
-    """Get current provider configuration (API key masked)."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        config = SLMConfig.load()
-        key = config.llm.api_key
-        masked = f"****{key[-4:]}" if len(key) > 8 else "****" if key else ""
-        return {
-            "provider": config.llm.provider or "none",
-            "model": config.llm.model,
-            "base_url": config.llm.api_base,
-            "api_key_masked": masked,
-            "has_key": bool(key),
-        }
-    except Exception as exc:
-        logger.exception("get_provider failed")
-        return {"error": "could not load configuration", "provider": "unknown"}
-
-
-@router.put("/provider")
-async def set_provider(request: Request):
-    """Set LLM provider. Body: {"provider": "openai", "api_key": "...", "model": "..."}"""
-    # Swapping the provider + API key redirects all LLM traffic (prompt/output
-    # interception risk) — admin-only, on top of mutation auth.
-    from superlocalmemory.server.route_mutations import authorize_route_mutation
-    from superlocalmemory.server.rbac_enforce import require_manage
-    _auth = authorize_route_mutation(request, operation="update",
-                                     source_agent_id="http-set-provider")
-    require_manage(request)
-    try:
-        body = await request.json()
-        provider = body.get("provider", "")
-        api_key = body.get("api_key", "")
-        model = body.get("model", "")
-        base_url = body.get("base_url", "")
-
-        from superlocalmemory.core.config import SLMConfig, LLMConfig
-        config = SLMConfig.load()
-
-        # Use preset base_url if not provided
-        if not base_url:
-            presets = SLMConfig.provider_presets()
-            preset = presets.get(provider, {})
-            base_url = preset.get("base_url", "")
-            if not model:
-                model = preset.get("model", "")
-
-        # Mutate only the LLM block — all other config is preserved.
-        config.llm = LLMConfig(
-            provider=provider,
-            model=model,
-            api_key=api_key,
-            api_base=base_url,
-        )
-        config.save()
-
-        return {"success": True, "provider": provider, "model": model}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Recall Trace ─────────────────────────────────────────────
-
-@router.post("/recall/trace")
-async def recall_trace(request: Request):
-    """Recall with per-channel score breakdown.
-
-    v3.4.64: Replaced WorkerPool.shared() (subprocess, blocks event loop,
-    worker crashes after ~15s) with daemon engine via run_in_executor.
-    Same fix as POST /api/search in v3.4.63.
-    """
-    import asyncio
-    import time as _time
-    try:
-        body = await request.json()
-        query = body.get("query", "")
-        limit = body.get("limit", CANONICAL_RECALL_LIMIT)
-        window = body.get("window", "") or ""
-        as_of_raw = (body.get("as_of", "") or "").strip()
-        raw_known_as_of = body.get("known_as_of", "")
-        raw_valid_at = body.get("valid_at", "")
-        if raw_known_as_of is not None and not isinstance(raw_known_as_of, str):
-            return JSONResponse({"error": "invalid_known_as_of"}, status_code=400)
-        if raw_valid_at is not None and not isinstance(raw_valid_at, str):
-            return JSONResponse({"error": "invalid_valid_at"}, status_code=400)
-        known_as_of_raw = (raw_known_as_of or "").strip()
-        valid_at_raw = (raw_valid_at or "").strip()
-        include_unknown = body.get("include_unknown", False)
-        if not isinstance(include_unknown, bool):
-            return JSONResponse({"error": "invalid_include_unknown"}, status_code=400)
-
-        # Normalize as_of at HTTP boundary. Invalid → 400.
-        _as_of: str | None = None
-        if as_of_raw:
-            from superlocalmemory.retrieval.temporal_utils import normalize_as_of
-            _as_of = normalize_as_of(as_of_raw)
-            if _as_of is None:
-                return JSONResponse(
-                    {"error": "invalid_as_of", "raw": as_of_raw}, status_code=400
-                )
-        def _normalize_named_time(raw: str, error: str) -> str | None | JSONResponse:
-            if not raw:
-                return None
-            from superlocalmemory.retrieval.temporal_utils import normalize_as_of
-            normalized = normalize_as_of(raw)
-            if normalized is None:
-                return JSONResponse({"error": error, "raw": raw}, status_code=400)
-            return normalized
-        _known_as_of = _normalize_named_time(known_as_of_raw, "invalid_known_as_of")
-        if isinstance(_known_as_of, JSONResponse):
-            return _known_as_of
-        _valid_at = _normalize_named_time(valid_at_raw, "invalid_valid_at")
-        if isinstance(_valid_at, JSONResponse):
-            return _valid_at
-
-        # Use daemon engine — already loaded, shares warm page cache.
-        # run_in_executor keeps event loop alive so browser doesn't abort.
-        from .helpers import get_engine_lazy
-        engine = get_engine_lazy(request.app.state)
-        if engine is None:
-            return JSONResponse({"error": "Engine not initialised"}, status_code=503)
-
-        loop = asyncio.get_event_loop()
-        t0 = _time.monotonic()
-        response = await loop.run_in_executor(
-            None,
-            lambda: engine.recall(
-                query, limit=limit, fast=False,
-                window=window or None, as_of=_as_of,
-                known_as_of=_known_as_of, valid_at=_valid_at,
-                include_unknown=include_unknown,
-                # Whoever asked, by the name they arrived under. Without a name
-                # the record of this recall is discarded and no outcome
-                # reported afterwards can be matched back to it.
-                session_id=_signal_session_id(),
-            ),
-        )
-        elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
-
-        from superlocalmemory.server.recall_serializer import (
-            recall_response_metadata,
-            serialize_recall_response,
-        )
-        results, no_confident_match = serialize_recall_response(
-            response,
-            limit=limit,
-            per_fact_max=300,
-            total_max=max(300, limit * 300),
-        )
-
-        # Record learning signals (non-blocking, non-critical)
-        try:
-            _record_learning_signals(query, results)
-        except Exception as _sig_exc:
-            import logging as _log
-            _log.getLogger(__name__).warning("Learning signal error: %s", _sig_exc)
-
-        return {
-            "query": query,
-            "query_type": getattr(response, "query_type", "semantic"),
-            "result_count": len(results),
-            "retrieval_time_ms": elapsed_ms,
-            "results": results,
-            "synthesis": "",
-            "no_confident_match": no_confident_match,
-            **recall_response_metadata(response),
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-def _record_learning_signals(query: str, results: list) -> None:
-    """Record feedback + co-retrieval + confidence boost for any recall."""
-    from superlocalmemory.core.config import SLMConfig
-
-    from superlocalmemory.infra.data_root import canonical_data_root
-    slm_dir = canonical_data_root()
-    config = SLMConfig.load()
-    pid = config.active_profile
-    fact_ids = [r.get("fact_id", "") for r in results[:10] if r.get("fact_id")]
-    if not fact_ids:
-        return
-
-    try:
-        from superlocalmemory.learning.feedback import FeedbackCollector
-        collector = FeedbackCollector(slm_dir / "learning.db")
-        collector.record_implicit(
-            profile_id=pid, query=query,
-            fact_ids_returned=fact_ids, fact_ids_available=fact_ids,
-        )
-    except Exception:
-        pass
-
-    try:
-        from superlocalmemory.learning.signals import LearningSignals
-        signals = LearningSignals(slm_dir / "learning.db")
-        signals.record_co_retrieval(pid, fact_ids)
-    except Exception:
-        pass
-
-    try:
-        from superlocalmemory.learning.signals import LearningSignals
-        mem_db = str(slm_dir / "memory.db")
-        for fid in fact_ids[:5]:
-            LearningSignals.boost_confidence(mem_db, fid)
-    except Exception:
-        pass
-
-
-# ── Trust Dashboard ──────────────────────────────────────────
-
-@router.get("/trust/dashboard")
-async def trust_dashboard(request: Request):
-    """Trust overview: per-agent scores, alerts. Queries DB directly."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.storage.database import DatabaseManager
-        from superlocalmemory.storage import schema as _schema
-        config = SLMConfig.load()
-        pid = config.active_profile
-
-        db_path = config.db_path
-        db = DatabaseManager(db_path)
-        db.initialize(_schema)
-
-        # Query trust scores from DB
-        agents = []
-        try:
-            rows = db.execute(
-                "SELECT target_id, target_type, trust_score, evidence_count, "
-                "last_updated FROM trust_scores WHERE profile_id = ? "
-                "ORDER BY trust_score DESC",
-                (pid,),
-            )
-            for r in rows:
-                d = dict(r)
-                agents.append({
-                    "target_id": d.get("target_id", ""),
-                    "target_type": d.get("target_type", ""),
-                    "trust_score": round(float(d.get("trust_score", 0.5)), 3),
-                    "evidence_count": d.get("evidence_count", 0),
-                    "last_updated": d.get("last_updated", ""),
-                })
-        except Exception:
-            pass
-
-        # Aggregate stats
-        avg = round(sum(a["trust_score"] for a in agents) / len(agents), 3) if agents else 0.5
-        alerts = [a for a in agents if a["trust_score"] < 0.3]
-
-        return {
-            "agents": agents,
-            "avg_trust": avg,
-            "alerts": alerts,
-            "total": len(agents),
-            "profile": pid,
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Math Health ──────────────────────────────────────────────
-
-@router.get("/math/health")
-async def math_health(request: Request):
-    """Mathematical layer health: Fisher, sheaf, Langevin status. Queries DB directly."""
-    try:
-        # v3.6.12 (math-1): report CONFIG-DERIVED status, not a hardcoded
-        # "active"/"healthy" for every layer. The old code had a dead `if engine:`
-        # (engine was always None) and returned all-green unconditionally — a
-        # false-assurance pane. We can't probe the recall subprocess from here,
-        # so report the real configured mode/threshold/temperature and label the
-        # status "configured" (or "unknown" if config can't load).
-        from superlocalmemory.core.config import SLMConfig
-        config = SLMConfig.load()
-        math = getattr(config, "math", None)
-        _status = "configured" if math is not None else "unknown"
-        health = {
-            "fisher": {
-                "status": _status,
-                "description": "Fisher-Rao information geometry for similarity",
-                "mode": getattr(math, "fisher_mode", None) if math else None,
-            },
-            "sheaf": {
-                "status": _status,
-                "description": "Sheaf cohomology for consistency detection",
-                "threshold": getattr(math, "sheaf_contradiction_threshold", None) if math else None,
-            },
-            "langevin": {
-                "status": _status,
-                "description": "Riemannian Langevin dynamics for lifecycle",
-                "temperature": getattr(math, "langevin_temperature", None) if math else None,
-            },
-        }
-        return {
-            "health": health,
-            "overall": _status,
-            "note": "config-derived; not a live runtime probe",
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Auto-Capture / Auto-Recall Config ────────────────────────
-
-@router.get("/auto-capture/config")
-async def get_auto_capture_config():
-    """Get auto-capture configuration."""
-    try:
-        from superlocalmemory.hooks.rules_engine import RulesEngine
-        from superlocalmemory.core.config import DEFAULT_BASE_DIR
-        rules = RulesEngine(config_path=DEFAULT_BASE_DIR / "config.json")
-        return {"config": rules.get_capture_config()}
-    except Exception as exc:
-        logger.exception("get_auto_capture_config failed")
-        return {"error": "internal error", "config": {}}
-
-
-@router.put("/auto-capture/config")
-async def set_auto_capture_config(request: Request):
-    """Update auto-capture config. Body: {"enabled": true, "capture_decisions": true, ...}"""
-    _require_manage(request)
-    try:
-        body = await request.json()
-        from superlocalmemory.hooks.rules_engine import RulesEngine
-        from superlocalmemory.core.config import DEFAULT_BASE_DIR
-        config_path = DEFAULT_BASE_DIR / "config.json"
-        rules = RulesEngine(config_path=config_path)
-        for key, value in body.items():
-            rules.update_rule("auto_capture", key, value)
-        rules.save(config_path)
-        return {"success": True, "config": rules.get_capture_config()}
-    except Exception as e:
-        return _internal_error()
-
-
-@router.get("/auto-recall/config")
-async def get_auto_recall_config():
-    """Get auto-recall configuration."""
-    try:
-        from superlocalmemory.hooks.rules_engine import RulesEngine
-        from superlocalmemory.core.config import DEFAULT_BASE_DIR
-        rules = RulesEngine(config_path=DEFAULT_BASE_DIR / "config.json")
-        return {"config": rules.get_recall_config()}
-    except Exception as exc:
-        logger.exception("get_auto_recall_config failed")
-        return {"error": "internal error", "config": {}}
-
-
-@router.put("/auto-recall/config")
-async def set_auto_recall_config(request: Request):
-    """Update auto-recall config."""
-    _require_manage(request)
-    try:
-        body = await request.json()
-        from superlocalmemory.hooks.rules_engine import RulesEngine
-        from superlocalmemory.core.config import DEFAULT_BASE_DIR
-        config_path = DEFAULT_BASE_DIR / "config.json"
-        rules = RulesEngine(config_path=config_path)
-        for key, value in body.items():
-            rules.update_rule("auto_recall", key, value)
-        rules.save(config_path)
-        return {"success": True, "config": rules.get_recall_config()}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Runtime behaviour config (v3.8.2 UX-1) ──────────────────
-# User-facing settings that take effect LIVE (no restart) via the
-# reconfigure_daemon_engine hot-swap path AND persist across restarts via
-# SLMConfig.save(). Scoped deliberately to fields that save() round-trips:
-# retrieval (asdict) + injection (explicit). Excludes setup-time/internal
-# knobs and any field save() doesn't persist (which would silently revert).
-_RUNTIME_CONFIG_FIELDS = (
-    # (section, field, kind, min, max)
-    ("retrieval", "top_k", "int", 1, 200),
-    ("retrieval", "use_cross_encoder", "bool", None, None),
-    ("injection", "enabled", "bool", None, None),
-    ("injection", "core_block_enabled", "bool", None, None),
-    ("injection", "core_block_max_facts", "int", 0, 50),
-)
-
-
-def _runtime_config_snapshot(config) -> dict:
-    """Current values of the exposed runtime fields, grouped by section."""
-    out: dict = {}
-    for section, field, *_ in _RUNTIME_CONFIG_FIELDS:
-        sec = getattr(config, section, None)
-        out.setdefault(section, {})[field] = (
-            getattr(sec, field, None) if sec is not None else None
-        )
-    return out
-
-
-@router.get("/runtime/config")
-async def get_runtime_config(request: Request):
-    """User-facing runtime behaviour settings.
-
-    Recall depth (top_k), reranker on/off (use_cross_encoder), and memory
-    injection (master + core-block). All apply live via the daemon hot-swap —
-    no restart — and persist across restarts.
-    """
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        config = getattr(request.app.state, "config", None) or SLMConfig.load()
-        return {"success": True, "config": _runtime_config_snapshot(config)}
-    except Exception:
-        return _internal_error()
-
-
-@router.put("/runtime/config")
-async def set_runtime_config(request: Request):
-    """Validate, persist, and hot-apply runtime behaviour settings.
-
-    Body: ``{"retrieval": {"top_k": 30}, "injection": {"enabled": false}}``.
-    Only known fields are accepted; a bad type/range is rejected 400 and
-    nothing is applied (fail-fast — never let a bad value wedge the engine).
-    """
-    _require_manage(request)
-    try:
-        import dataclasses as _dc
-        from superlocalmemory.core.config import SLMConfig
-
-        body = await request.json()
-        if not isinstance(body, dict):
-            return JSONResponse({"error": "body must be an object"}, status_code=400)
-
-        # Validate everything BEFORE mutating anything.
-        updates: dict[str, dict] = {}
-        for section, field, kind, lo, hi in _RUNTIME_CONFIG_FIELDS:
-            sec_in = body.get(section)
-            if not isinstance(sec_in, dict) or field not in sec_in:
-                continue
-            val = sec_in[field]
-            if kind == "bool":
-                if not isinstance(val, bool):
-                    return JSONResponse(
-                        {"error": f"{section}.{field} must be true or false"},
-                        status_code=400,
-                    )
-            elif kind == "int":
-                # bool is an int subclass — reject it explicitly.
-                if isinstance(val, bool) or not isinstance(val, int):
-                    return JSONResponse(
-                        {"error": f"{section}.{field} must be an integer"},
-                        status_code=400,
-                    )
-                if (lo is not None and val < lo) or (hi is not None and val > hi):
-                    return JSONResponse(
-                        {"error": f"{section}.{field} must be between {lo} and {hi}"},
-                        status_code=400,
-                    )
-            updates.setdefault(section, {})[field] = val
-
-        if not updates:
-            return JSONResponse(
-                {"error": "no known runtime settings in request body"},
-                status_code=400,
-            )
-
-        # These are plain behaviour flags read per-recall — NOT model/mode
-        # swaps. So we apply them the light way: swap the sub-config objects on
-        # the LIVE config the daemon+engine already hold, then persist to disk.
-        # This avoids the heavyweight engine drain+rebuild (which reloads
-        # models and can time out draining in-flight recalls) — the running
-        # engine simply reads the new values on its next recall/injection.
-        live = getattr(request.app.state, "config", None) or SLMConfig.load()
-        targets = [live]
-        engine = getattr(request.app.state, "engine", None)
-        eng_cfg = getattr(engine, "_config", None) if engine is not None else None
-        if eng_cfg is not None and eng_cfg is not live:
-            targets.append(eng_cfg)
-        for cfg in targets:
-            for section, changes in updates.items():
-                sec = getattr(cfg, section, None)
-                if sec is None:
-                    continue
-                # replace() yields a NEW sub-config (works frozen or mutable);
-                # assigning the attribute is an atomic reference swap.
-                setattr(cfg, section, _dc.replace(sec, **changes))
-        request.app.state.config = live
-        live.save(mode_change=False)  # durable across restart
-        return {"success": True, "config": _runtime_config_snapshot(live)}
-    except Exception:
-        return _internal_error()
-
-
-# ── IDE Status ───────────────────────────────────────────────
-
-@router.get("/ide/status")
-async def ide_status():
-    """Get IDE connection status."""
-    try:
-        from superlocalmemory.hooks.ide_connector import IDEConnector
-        connector = IDEConnector()
-        return {"ides": connector.get_status()}
-    except Exception as exc:
-        logger.exception("ide_status failed")
-        return {"error": "internal error", "ides": []}
-
-
-@router.post("/ide/connect")
-async def ide_connect(request: Request):
-    """Connect an IDE. Body: {"ide": "cursor"} or {} for all."""
-    try:
-        body = await request.json()
-        ide = body.get("ide", "")
-
-        from superlocalmemory.hooks.ide_connector import IDEConnector
-        connector = IDEConnector()
-
-        if ide:
-            success = connector.connect(ide)
-            return {"success": success, "ide": ide}
-        else:
-            results = connector.connect_all()
-            return {"results": results}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Active Memory (V3.1) ────────────────────────────────────
-
-@router.get("/learning/signals")
-async def learning_signals():
-    """Get zero-cost learning signal statistics."""
-    try:
-        from superlocalmemory.learning.signals import LearningSignals
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.server.routes.helpers import DB_PATH
-        learning_db = DB_PATH.parent / "learning.db"
-        signals = LearningSignals(learning_db)
-        config = SLMConfig.load()
-        pid = config.active_profile
-        return {"success": True, **signals.get_signal_stats(pid)}
-    except Exception as exc:
-        logger.exception("learning_signals failed")
-        return {"success": False, "error": "internal error"}
-
-
-@router.post("/learning/consolidate")
-async def run_consolidation(request: Request):
-    """Run sleep-time consolidation. Body: {dry_run: true/false}."""
-    try:
-        body = await request.json()
-        dry_run = body.get("dry_run", False)
-        # Run the full cycle OUT OF PROCESS. Step 5 trains the LightGBM ranker
-        # (online _run_shadow_cycle or legacy cold-start); importing lightgbm
-        # in the torch-warm daemon loads a second libomp and SIGSEGVs it (see
-        # lightgbm_subprocess module docstring). Isolation is the fix.
-        from superlocalmemory.learning.lightgbm_subprocess import (
-            run_consolidation_isolated,
-        )
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.server.routes.helpers import DB_PATH
-        from fastapi.concurrency import run_in_threadpool
-
-        config = SLMConfig.load()
-        learning_db = DB_PATH.parent / "learning.db"
-        _require_manage_for_profile(request, config.active_profile)
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-learning-consolidate",
-            profile_id=config.active_profile,
-        )
-        result = await run_in_threadpool(
-            run_consolidation_isolated,
-            str(DB_PATH),
-            str(learning_db),
-            config.active_profile,
-            dry_run=dry_run,
-        )
-        if result.get("error"):
-            return {"success": False, "error": result["error"]}
-        # Step-5 training may have promoted a new model — drop the daemon's
-        # cached model so the next recall reloads it from learning.db.
-        if not dry_run:
-            try:
-                from superlocalmemory.learning.model_cache import invalidate
-                invalidate(config.active_profile)
-            except Exception:
-                pass
-        stats = result.get("stats") or {}
-        authorization.complete()
-        return {"success": True, **stats}
-    except HTTPException:
-        raise
-    except Exception as exc:
-        logger.exception("run_consolidation failed")
-        return {"success": False, "error": "internal error"}
-
-
-@router.get("/hooks/status")
-async def hooks_status():
-    """Check if Claude Code hooks are installed."""
-    try:
-        from superlocalmemory.hooks.claude_code_hooks import check_status
-        return {"success": True, **check_status()}
-    except Exception as exc:
-        logger.exception("hooks_status failed")
-        return {"success": False, "error": "internal error"}
-
-
-# ── Phase 6: V3.2 API Endpoints ──────────────────────────────
-# 9 new endpoints for the V3.2 dashboard tabs:
-#   Auto-Invoke (2), Associations (2), Consolidation (2),
-#   Core Memory (2), VectorStore (1)
-#
-# Rules enforced:
-#   01 - Profile scoping on ALL endpoints
-#   06 - No engine import from routes (direct sqlite3)
-#   11 - Parameterized SQL everywhere
-#   18 - WorkerPool for POST consolidation/trigger
-#   19 - Silent errors with JSONResponse
-# ──────────────────────────────────────────────────────────────
-
-
-def _load_auto_invoke_json() -> dict:
-    """Load auto-invoke config from config.json's auto_invoke section."""
-    from superlocalmemory.server.routes.helpers import MEMORY_DIR
-    config_path = MEMORY_DIR / "config.json"
-    if config_path.exists():
-        try:
-            data = json.loads(config_path.read_text())
-            return data.get("auto_invoke", {})
-        except (json.JSONDecodeError, IOError):
-            pass
-    return {}
-
-
-def _save_auto_invoke_json(auto_invoke_data: dict) -> None:
-    """Persist auto-invoke config into config.json's auto_invoke section."""
-    from superlocalmemory.server.routes.helpers import MEMORY_DIR
-    config_path = MEMORY_DIR / "config.json"
-    cfg: dict = {}
-    if config_path.exists():
-        try:
-            cfg = json.loads(config_path.read_text())
-        except (json.JSONDecodeError, IOError):
-            pass
-    cfg["auto_invoke"] = auto_invoke_data
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    config_path.write_text(json.dumps(cfg, indent=2))
-
-
-# ── 1. GET /api/v3/auto-invoke/config ─────────────────────────
-
-@router.get("/auto-invoke/config")
-async def get_auto_invoke_config(request: Request):
-    """Get current auto-invoke configuration."""
-    try:
-        from superlocalmemory.core.config import AutoInvokeConfig
-        defaults = AutoInvokeConfig()
-
-        persisted = _load_auto_invoke_json()
-
-        return {
-            "enabled": persisted.get("enabled", defaults.enabled),
-            "min_score": persisted.get("min_score", defaults.fok_threshold),
-            "weights": persisted.get("weights", dict(defaults.weights)),
-            "act_r_mode": persisted.get("act_r_mode", defaults.use_act_r),
-            "invocation_count": persisted.get("invocation_count", 0),
-            "last_invocation": persisted.get("last_invocation", None),
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 2. PUT /api/v3/auto-invoke/config ─────────────────────────
-
-@router.put("/auto-invoke/config")
-async def set_auto_invoke_config(request: Request):
-    """Update auto-invoke configuration.
-
-    Body: {"enabled": true, "min_score": 0.15, "weights": {...}}
-    """
-    _require_manage(request)
-    try:
-        body = await request.json()
-
-        # Validate min_score range
-        min_score = body.get("min_score")
-        if min_score is not None and (min_score < 0 or min_score > 1):
-            return JSONResponse(
-                {"error": "min_score must be between 0 and 1"},
-                status_code=400,
-            )
-
-        # Load existing, merge updates
-        from superlocalmemory.core.config import AutoInvokeConfig
-        defaults = AutoInvokeConfig()
-        persisted = _load_auto_invoke_json()
-
-        updated = {
-            "enabled": body.get("enabled", persisted.get("enabled", defaults.enabled)),
-            "min_score": body.get("min_score", persisted.get("min_score", defaults.fok_threshold)),
-            "weights": body.get("weights", persisted.get("weights", dict(defaults.weights))),
-            "act_r_mode": body.get("act_r_mode", persisted.get("act_r_mode", defaults.use_act_r)),
-            "invocation_count": persisted.get("invocation_count", 0),
-            "last_invocation": persisted.get("last_invocation", None),
-        }
-        _save_auto_invoke_json(updated)
-
-        return updated
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 3. GET /api/v3/associations ───────────────────────────────
-
-@router.get("/associations")
-async def get_associations(
-    request: Request,
-    limit: int = 50,
-    type: str = "",
-    profile: str = "",
-):
-    """Get association edges for a profile with content previews."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3
-
-        if not DB_PATH.exists():
-            return {"edges": [], "total": 0}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = sqlite3.Row
-
-        # Build query with optional type filter (parameterized)
-        params: list = [pid]
-        sql = (
-            "SELECT ae.edge_id, ae.source_fact_id, ae.target_fact_id, "
-            "ae.association_type, ae.weight, ae.co_access_count, ae.created_at, "
-            "sf.content AS source_content, tf.content AS target_content "
-            "FROM association_edges ae "
-            "LEFT JOIN atomic_facts sf ON sf.fact_id = ae.source_fact_id "
-            "LEFT JOIN atomic_facts tf ON tf.fact_id = ae.target_fact_id "
-            "WHERE ae.profile_id = ? "
-        )
-        if type:
-            sql += "AND ae.association_type = ? "
-            params.append(type)
-        sql += "ORDER BY ae.created_at DESC LIMIT ?"
-        params.append(limit)
-
-        rows = conn.execute(sql, params).fetchall()
-
-        # Total count (separate query for pagination info)
-        count_sql = "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?"
-        count_params: list = [pid]
-        if type:
-            count_sql += " AND association_type = ?"
-            count_params.append(type)
-        total = conn.execute(count_sql, count_params).fetchone()[0]
-
-        conn.close()
-
-        edges = []
-        for r in rows:
-            row = dict(r)
-            source_content = row.get("source_content") or ""
-            target_content = row.get("target_content") or ""
-            edges.append({
-                "edge_id": row["edge_id"],
-                "source_fact_id": row["source_fact_id"],
-                "target_fact_id": row["target_fact_id"],
-                "association_type": row["association_type"],
-                "weight": round(float(row["weight"]), 3),
-                "co_access_count": row["co_access_count"],
-                "created_at": row["created_at"],
-                "source_preview": source_content[:100],
-                "target_preview": target_content[:100],
-            })
-
-        return {"edges": edges, "total": total}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 4. GET /api/v3/associations/stats ─────────────────────────
-
-@router.get("/associations/stats")
-async def get_association_stats(request: Request, profile: str = ""):
-    """Get association graph statistics."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3
-
-        if not DB_PATH.exists():
-            return {
-                "total_edges": 0,
-                "by_type": {},
-                "community_count": 0,
-                "avg_weight": 0.0,
-                "top_connected_facts": [],
-            }
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = sqlite3.Row
-
-        # Total edges
-        total = conn.execute(
-            "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?",
-            (pid,),
-        ).fetchone()[0]
-
-        # Edges by type
-        by_type_rows = conn.execute(
-            "SELECT association_type, COUNT(*) AS cnt "
-            "FROM association_edges WHERE profile_id = ? "
-            "GROUP BY association_type",
-            (pid,),
-        ).fetchall()
-        by_type = {row["association_type"]: row["cnt"] for row in by_type_rows}
-
-        # Average weight
-        avg_row = conn.execute(
-            "SELECT AVG(weight) AS avg_w FROM association_edges "
-            "WHERE profile_id = ?",
-            (pid,),
-        ).fetchone()
-        avg_weight = round(float(avg_row["avg_w"] or 0), 3)
-
-        # Community count from fact_importance table
-        community_count = 0
-        try:
-            cc_row = conn.execute(
-                "SELECT COUNT(DISTINCT community_id) AS cnt "
-                "FROM fact_importance "
-                "WHERE profile_id = ? AND community_id IS NOT NULL",
-                (pid,),
-            ).fetchone()
-            community_count = cc_row["cnt"] if cc_row else 0
-        except Exception:
-            pass
-
-        # Top connected facts (by degree = count of edges as source or target)
-        top_facts = []
-        try:
-            degree_rows = conn.execute(
-                "SELECT fact_id, degree FROM ("
-                "  SELECT source_fact_id AS fact_id, COUNT(*) AS degree "
-                "  FROM association_edges WHERE profile_id = ? "
-                "  GROUP BY source_fact_id "
-                "  UNION ALL "
-                "  SELECT target_fact_id AS fact_id, COUNT(*) AS degree "
-                "  FROM association_edges WHERE profile_id = ? "
-                "  GROUP BY target_fact_id "
-                ") GROUP BY fact_id ORDER BY SUM(degree) DESC LIMIT 5",
-                (pid, pid),
-            ).fetchall()
-            for dr in degree_rows:
-                fact_id = dr["fact_id"]
-                preview_row = conn.execute(
-                    "SELECT content FROM atomic_facts WHERE fact_id = ?",
-                    (fact_id,),
-                ).fetchone()
-                preview = (dict(preview_row).get("content", "")[:80]) if preview_row else ""
-                top_facts.append({
-                    "fact_id": fact_id,
-                    "degree": dr["degree"],
-                    "preview": preview,
-                })
-        except Exception:
-            pass
-
-        conn.close()
-
-        return {
-            "total_edges": total,
-            "by_type": by_type,
-            "community_count": community_count,
-            "avg_weight": avg_weight,
-            "top_connected_facts": top_facts,
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 5. GET /api/v3/consolidation/status ───────────────────────
-
-@router.get("/consolidation/status")
-async def get_consolidation_status(request: Request, profile: str = ""):
-    """Get consolidation status and last run results."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        from superlocalmemory.core.config import SLMConfig
-        import sqlite3
-
-        config = SLMConfig.load()
-        cons_cfg = config.consolidation
-
-        result: dict = {
-            "enabled": cons_cfg.enabled,
-            "last_run": None,
-            "last_result": None,
-            "triggers": {
-                "session_end": cons_cfg.session_trigger,
-                "idle_timeout": cons_cfg.idle_timeout_seconds,
-                "step_count": cons_cfg.step_count_trigger,
-                "scheduled_sessions": cons_cfg.scheduled_sessions,
-            },
-            "store_count_since_last": 0,
-        }
-
-        if not DB_PATH.exists():
-            return result
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = sqlite3.Row
-
-        # Last consolidation log entry
-        try:
-            last_row = conn.execute(
-                "SELECT timestamp, action_type, reason "
-                "FROM consolidation_log "
-                "WHERE profile_id = ? ORDER BY timestamp DESC LIMIT 1",
-                (pid,),
-            ).fetchone()
-            if last_row:
-                result["last_run"] = dict(last_row).get("timestamp")
-        except Exception:
-            pass
-
-        # Count blocks compiled (proxy for last consolidation result)
-        try:
-            block_count = conn.execute(
-                "SELECT COUNT(*) FROM core_memory_blocks WHERE profile_id = ?",
-                (pid,),
-            ).fetchone()[0]
-            edge_count = conn.execute(
-                "SELECT COUNT(*) FROM association_edges WHERE profile_id = ?",
-                (pid,),
-            ).fetchone()[0]
-            result["last_result"] = {
-                "blocks_compiled": block_count,
-                "total_edges": edge_count,
-            }
-        except Exception:
-            pass
-
-        # Store count since last consolidation
-        try:
-            if result["last_run"]:
-                sc = conn.execute(
-                    "SELECT COUNT(*) FROM atomic_facts "
-                    "WHERE profile_id = ? AND created_at > ?",
-                    (pid, result["last_run"]),
-                ).fetchone()[0]
-                result["store_count_since_last"] = sc
-            else:
-                sc = conn.execute(
-                    "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?",
-                    (pid,),
-                ).fetchone()[0]
-                result["store_count_since_last"] = sc
-        except Exception:
-            pass
-
-        conn.close()
-        return result
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 6. POST /api/v3/consolidation/trigger ─────────────────────
-
-@router.post("/consolidation/trigger")
-async def trigger_consolidation(request: Request):
-    """Trigger consolidation manually.
-
-    Body: {"lightweight": false, "profile": ""}
-    Runs under the daemon's profile-runtime operation lease (Rule 18) so a
-    concurrent profile switch cannot commit mid-consolidation.
-    """
-    try:
-        body = await request.json()
-        lightweight = body.get("lightweight", False)
-        profile = body.get("profile", "")
-
-        from superlocalmemory.server.routes.helpers import get_active_profile
-        pid = _resolve_mutation_profile(profile)
-        _require_manage_for_profile(request, pid)
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-consolidation-trigger",
-            profile_id=pid,
-        )
-
-        # 4.0.8: the body of this handler moved to server/consolidation_runner
-        # so the periodic daemon trigger and this endpoint run the SAME code
-        # under the SAME lock. Two copies would be two definitions of
-        # "consolidated", and only one of them would get maintained.
-        from superlocalmemory.server.consolidation_runner import (
-            run_full_consolidation,
-        )
-
-        # background=true returns as soon as the pass is scheduled. The
-        # session-end hook needs this: a full consolidation runs for seconds to
-        # minutes, and a hook that waits for it either blocks the user's shell
-        # or times out and wrongly concludes the run failed.
-        if body.get("background"):
-            import asyncio as _asyncio
-
-            _app_state = request.app.state
-            _asyncio.create_task(
-                run_full_consolidation(
-                    _app_state, pid, lightweight=lightweight, trigger="hook",
-                )
-            )
-            authorization.complete()
-            return {"success": True, "started": True, "background": True}
-
-        result = await run_full_consolidation(
-            request.app.state, pid, lightweight=lightweight, trigger="http",
-        )
-        authorization.complete()
-        return {"success": True, **result}
-    except HTTPException:
-        raise
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 7. GET /api/v3/core-memory ────────────────────────────────
-
-@router.get("/core-memory")
-async def get_core_memory(request: Request, profile: str = ""):
-    """Get all Core Memory blocks for a profile."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3
-
-        if not DB_PATH.exists():
-            return {"blocks": [], "total_chars": 0, "char_limit": 2000}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = sqlite3.Row
-
-        rows = conn.execute(
-            "SELECT block_id, block_type, content, char_count, version, "
-            "compiled_by, updated_at FROM core_memory_blocks "
-            "WHERE profile_id = ? ORDER BY block_type",
-            (pid,),
-        ).fetchall()
-
-        conn.close()
-
-        blocks = []
-        total_chars = 0
-        for r in rows:
-            row = dict(r)
-            char_count = row.get("char_count", 0) or len(row.get("content", ""))
-            total_chars += char_count
-            blocks.append({
-                "block_id": row["block_id"],
-                "block_type": row["block_type"],
-                "content": row["content"],
-                "char_count": char_count,
-                "version": row["version"],
-                "compiled_by": row["compiled_by"],
-                "updated_at": row["updated_at"],
-            })
-
-        return {"blocks": blocks, "total_chars": total_chars, "char_limit": 2000}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 8. PUT /api/v3/core-memory/{block_id} ─────────────────────
-
-@router.put("/core-memory/{block_id}")
-async def update_core_memory_block(block_id: str, request: Request):
-    """Update a Core Memory block's content manually.
-
-    Body: {"content": "Updated content..."}
-    """
-    try:
-        body = await request.json()
-        content = body.get("content")
-        if content is None:
-            return JSONResponse(
-                {"error": "content field is required"},
-                status_code=400,
-            )
-
-        from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
-        from superlocalmemory.storage.memory_write import memory_write
-        from datetime import datetime, timezone
-
-        if not DB_PATH.exists():
-            return JSONResponse(
-                {"error": "Database not found"},
-                status_code=404,
-            )
-
-        pid = get_active_profile()
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-core-memory-update",
-            profile_id=pid,
-            fact_id=block_id,
-            content_preview=str(content),
-        )
-
-        now = datetime.now(timezone.utc).isoformat()
-        # memory_write: process write lock + busy_timeout.
-        # SELECT + UPDATE + read-back are atomic inside the same connection.
-        with memory_write(DB_PATH) as conn:
-            # Verify block exists
-            existing = conn.execute(
-                "SELECT block_id, profile_id, block_type, version "
-                "FROM core_memory_blocks WHERE block_id = ? AND profile_id = ?",
-                (block_id, pid),
-            ).fetchone()
-
-            if not existing:
-                raise HTTPException(status_code=404, detail=f"Block {block_id} not found")
-
-            new_version = dict(existing)["version"] + 1
-            conn.execute(
-                "UPDATE core_memory_blocks SET content = ?, char_count = ?, "
-                "version = ?, compiled_by = 'manual', updated_at = ? "
-                "WHERE block_id = ? AND profile_id = ?",
-                (content, len(content), new_version, now, block_id, pid),
-            )
-            # Read back updated block while connection is still open.
-            updated = conn.execute(
-                "SELECT block_id, block_type, content, char_count, version, "
-                "compiled_by, updated_at FROM core_memory_blocks "
-                "WHERE block_id = ? AND profile_id = ?",
-                (block_id, pid),
-            ).fetchone()
-            updated_dict = dict(updated) if updated else {"block_id": block_id, "updated": True}
-
-        authorization.complete()
-        return updated_dict
-    except HTTPException:
-        raise
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 9. GET /api/v3/vector-store/status ────────────────────────
-
-@router.get("/vector-store/status")
-async def get_vector_store_status(request: Request, profile: str = ""):
-    """Get VectorStore health and statistics."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.server.routes.helpers import DB_PATH
-        import sqlite3
-
-        config = SLMConfig.load()
-
-        result: dict = {
-            "available": False,
-            "provider": "sqlite-vec",
-            "dimension": config.embedding.dimension,
-            "embedding_model": config.embedding.model_name,
-            "total_vectors": 0,
-            "binary_quantization": False,
-            "binary_quantization_threshold": 100000,
-            "fallback_to_ann": False,
-        }
-
-        # Check if sqlite-vec extension is available
-        try:
-            import sqlite_vec  # noqa: F401
-            result["available"] = True
-        except ImportError:
-            result["fallback_to_ann"] = True
-
-        # Count vectors in embedding_metadata
-        if DB_PATH.exists():
-            try:
-                conn = get_read_connection(DB_PATH)
-                count = conn.execute(
-                    "SELECT COUNT(*) FROM embedding_metadata WHERE profile_id = ?",
-                    (pid,),
-                ).fetchone()[0]
-                result["total_vectors"] = count
-                conn.close()
-            except Exception:
-                pass
-
-        return result
-    except Exception as e:
-        return _internal_error()
-
-
-# ── Phase 10: V3.3 API Endpoints ────────────────────────────
-# 7 new endpoints for the V3.3 dashboard:
-#   Forgetting (2), Quantization (1), CCQ (1),
-#   Soft Prompts (1), Process Health (1), V3.3 Overview (1)
-#
-# Rules enforced:
-#   01 - Profile scoping on ALL endpoints
-#   06 - No engine import from routes (direct sqlite3)
-#   11 - Parameterized SQL everywhere
-#   19 - Silent errors with JSONResponse
-# ──────────────────────────────────────────────────────────────
-
-
-# ── 1a. GET /api/v3/forgetting/stats ────────────────────────
-
-@router.get("/forgetting/stats")
-async def forgetting_stats(request: Request, profile: str = ""):
-    """Get memory retention zone distribution."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
-
-        zones = {"active": 0, "warm": 0, "cold": 0, "archive": 0, "forgotten": 0}
-        total = 0
-
-        if not DB_PATH.exists():
-            return {"total": total, "zones": zones}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = _sqlite3.Row
-
-        try:
-            rows = conn.execute(
-                "SELECT lifecycle_zone, COUNT(*) AS cnt "
-                "FROM fact_retention WHERE profile_id = ? "
-                "GROUP BY lifecycle_zone",
-                (pid,),
-            ).fetchall()
-            for row in rows:
-                zone = dict(row)["lifecycle_zone"]
-                cnt = dict(row)["cnt"]
-                if zone in zones:
-                    zones[zone] = cnt
-                total += cnt
-        except Exception:
-            # Table may not exist in older DBs -- graceful fallback
-            pass
-
-        conn.close()
-        return {"total": total, "zones": zones}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1b. POST /api/v3/forgetting/run ─────────────────────────
-
-@router.post("/forgetting/run")
-async def run_forgetting(request: Request):
-    """Trigger a forgetting decay cycle.
-
-    Body: {"profile": ""} (optional profile override).
-    """
-    try:
-        body = await request.json()
-        profile = body.get("profile", "")
-
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        from superlocalmemory.storage.memory_write import memory_write as _memory_write
-        pid = _resolve_mutation_profile(profile)
-        _require_manage_for_profile(request, pid)
-
-        if not DB_PATH.exists():
-            return {"success": False, "error": "Database not found"}
-
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-forgetting-run",
-            profile_id=pid,
-        )
-
-        # memory_write: process write lock + busy_timeout — all UPDATEs atomic.
-        updated = 0
-        try:
-            with _memory_write(DB_PATH) as conn:
-                # Apply Ebbinghaus decay: reduce retention for facts not accessed recently
-                # Formula: retention *= exp(-0.1) for each cycle (simplified batch decay)
-                conn.execute(
-                    "UPDATE fact_retention "
-                    "SET retention_score = MAX(0.0, retention_score * 0.9), "
-                    "    last_computed_at = datetime('now') "
-                    "WHERE profile_id = ? "
-                    "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                    (pid,),
-                )
-                updated = conn.total_changes
-
-                # Transition zones based on new retention scores
-                zone_thresholds = [
-                    ("forgotten", 0.05),
-                    ("archive", 0.15),
-                    ("cold", 0.35),
-                    ("warm", 0.65),
-                ]
-                for zone, threshold in zone_thresholds:
-                    conn.execute(
-                        "UPDATE fact_retention "
-                        "SET lifecycle_zone = ? "
-                        "WHERE profile_id = ? "
-                        "AND retention_score < ? "
-                        "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                        (zone, pid, threshold),
-                    )
-
-                # Ensure high-retention facts are active
-                conn.execute(
-                    "UPDATE fact_retention "
-                    "SET lifecycle_zone = 'active' "
-                    "WHERE profile_id = ? AND retention_score >= 0.65 "
-                    "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                    (pid,),
-                )
-
-                from superlocalmemory.core.lifecycle_state import reconcile_profile_lifecycle
-                reconcile_profile_lifecycle(conn, pid)
-        except Exception as exc:
-            logger.exception("run_forgetting decay failed")
-            return {"success": False, "error": "internal error"}
-
-        authorization.complete()
-        return {"success": True, "facts_decayed": updated, "profile": pid}
-    except HTTPException:
-        raise
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1c. GET /api/v3/quantization/stats ──────────────────────
-
-@router.get("/quantization/stats")
-async def quantization_stats(request: Request, profile: str = ""):
-    """Get embedding quantization tier distribution."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
-
-        tiers = {"float32": 0, "int8": 0, "polar4": 0, "polar2": 0}
-        total = 0
-        compression_ratio = 1.0
-
-        if not DB_PATH.exists():
-            return {"total": total, "tiers": tiers, "compression_ratio": compression_ratio}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = _sqlite3.Row
-
-        try:
-            rows = conn.execute(
-                "SELECT quantization_level, COUNT(*) AS cnt "
-                "FROM embedding_quantization_metadata "
-                "WHERE profile_id = ? "
-                "GROUP BY quantization_level",
-                (pid,),
-            ).fetchall()
-            for row in rows:
-                level = dict(row)["quantization_level"]
-                cnt = dict(row)["cnt"]
-                if level in tiers:
-                    tiers[level] = cnt
-                total += cnt
-        except Exception:
-            pass
-
-        # Compute compression ratio from actual sizes if available
-        try:
-            size_row = conn.execute(
-                "SELECT "
-                "SUM(CASE WHEN bit_width = 32 THEN 768 * 4 ELSE "
-                "    COALESCE(compressed_size_bytes, 768 * bit_width / 8) END) AS actual, "
-                "SUM(768 * 4) AS uncompressed "
-                "FROM embedding_quantization_metadata "
-                "WHERE profile_id = ?",
-                (pid,),
-            ).fetchone()
-            if size_row:
-                d = dict(size_row)
-                uncompressed = d.get("uncompressed") or 0
-                actual = d.get("actual") or 0
-                if actual > 0 and uncompressed > 0:
-                    compression_ratio = round(uncompressed / actual, 2)
-        except Exception:
-            pass
-
-        conn.close()
-        return {"total": total, "tiers": tiers, "compression_ratio": compression_ratio}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1d. GET /api/v3/ccq/blocks ──────────────────────────────
-
-@router.get("/ccq/blocks")
-async def ccq_blocks(request: Request, profile: str = "", limit: int = 50):
-    """Get CCQ consolidated blocks."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
-
-        if not DB_PATH.exists():
-            return {"blocks": [], "total": 0}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = _sqlite3.Row
-
-        blocks = []
-        total = 0
-        try:
-            rows = conn.execute(
-                "SELECT block_id, content, source_fact_ids, char_count, "
-                "compiled_by, cluster_id, created_at "
-                "FROM ccq_consolidated_blocks "
-                "WHERE profile_id = ? "
-                "ORDER BY created_at DESC LIMIT ?",
-                (pid, limit),
-            ).fetchall()
-
-            for row in rows:
-                d = dict(row)
-                source_ids = []
-                try:
-                    source_ids = json.loads(d.get("source_fact_ids", "[]"))
-                except (json.JSONDecodeError, TypeError):
-                    pass
-                blocks.append({
-                    "block_id": d["block_id"],
-                    "content": d["content"],
-                    "source_fact_count": len(source_ids),
-                    "char_count": d["char_count"],
-                    "compiled_by": d["compiled_by"],
-                    "cluster_id": d["cluster_id"],
-                    "created_at": d["created_at"],
-                })
-
-            count_row = conn.execute(
-                "SELECT COUNT(*) FROM ccq_consolidated_blocks "
-                "WHERE profile_id = ?",
-                (pid,),
-            ).fetchone()
-            total = count_row[0] if count_row else 0
-        except Exception:
-            pass
-
-        conn.close()
-        return {"blocks": blocks, "total": total}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1e. GET /api/v3/soft-prompts ─────────────────────────────
-
-@router.get("/soft-prompts")
-async def get_soft_prompts(request: Request, profile: str = ""):
-    """Get active soft prompt templates."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
-
-        if not DB_PATH.exists():
-            return {"prompts": [], "total": 0, "total_tokens": 0}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = _sqlite3.Row
-
-        prompts = []
-        total_tokens = 0
-        try:
-            rows = conn.execute(
-                "SELECT prompt_id, category, content, confidence, "
-                "effectiveness, token_count, retention_score, "
-                "active, version, created_at, updated_at "
-                "FROM soft_prompt_templates "
-                "WHERE profile_id = ? AND active = 1 "
-                "ORDER BY confidence DESC",
-                (pid,),
-            ).fetchall()
-
-            for row in rows:
-                d = dict(row)
-                tokens = d.get("token_count", 0)
-                total_tokens += tokens
-                prompts.append({
-                    "prompt_id": d["prompt_id"],
-                    "category": d["category"],
-                    "content": d["content"][:200],
-                    "confidence": round(float(d["confidence"]), 3),
-                    "effectiveness": round(float(d.get("effectiveness", 0.5)), 3),
-                    "token_count": tokens,
-                    "retention_score": round(float(d.get("retention_score", 1.0)), 3),
-                    "version": d["version"],
-                    "created_at": d["created_at"],
-                })
-        except Exception:
-            pass
-
-        conn.close()
-        return {"prompts": prompts, "total": len(prompts), "total_tokens": total_tokens}
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1f. GET /api/v3/health/processes ─────────────────────────
-
-@router.get("/health/processes")
-async def process_health(request: Request):
-    """Get SLM process health status."""
-    _resolve_profile(request)
-    try:
-        import os as _os
-
-        processes = {
-            "mcp_server": {"pid": _os.getpid(), "status": "running"},
-            "parent": {"pid": _os.getppid(), "status": "unknown"},
-        }
-
-        # Check parent process
-        try:
-            _os.kill(_os.getppid(), 0)
-            processes["parent"]["status"] = "running"
-        except ProcessLookupError:
-            processes["parent"]["status"] = "dead"
-        except PermissionError:
-            processes["parent"]["status"] = "running"
-        except OSError:
-            processes["parent"]["status"] = "unknown"
-
-        # Check worker pool status
-        worker_status = "unavailable"
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            pool = WorkerPool.shared()
-            worker_status = "running" if pool else "stopped"
-        except Exception:
-            pass
-        processes["worker_pool"] = {"status": worker_status}
-
-        # Memory usage of current process (approximate)
-        from superlocalmemory.core.platform_utils import get_rss_mb
-        memory_mb = round(get_rss_mb(), 1)
-
-        return {
-            "processes": processes,
-            "memory_mb": memory_mb,
-            "healthy": processes["parent"]["status"] != "dead",
-        }
-    except Exception as e:
-        return _internal_error()
-
-
-# ── 1g. GET /api/v3/v33/overview ─────────────────────────────
-
-# ── v3.4.1: Graph Communities ──────────────────────────────────
-
-@router.get("/graph/communities")
-async def get_graph_communities(request: Request, profile: str = ""):
-    """Get community assignments with TF-IDF labels, entities, and colors.
-
-    v3.4.1: Uses TF-IDF labels from config table (computed by GraphAnalyzer
-    at consolidation time). Falls back to inline word frequency if labels
-    not yet computed.
-    """
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3
-
-        if not DB_PATH.exists():
-            return {"communities": [], "total": 0}
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = sqlite3.Row
-
-        # Get community member counts and average pagerank
-        comm_rows = conn.execute(
-            "SELECT community_id, COUNT(*) AS member_count, "
-            "AVG(pagerank_score) AS pagerank_avg "
-            "FROM fact_importance "
-            "WHERE profile_id = ? AND community_id IS NOT NULL "
-            "GROUP BY community_id ORDER BY member_count DESC",
-            (pid,),
-        ).fetchall()
-
-        if not comm_rows:
-            conn.close()
-            return {"communities": [], "total": 0}
-
-        # Load TF-IDF labels from config table
-        tfidf_labels = {}
-        try:
-            label_key = "community_labels_" + pid
-            label_row = conn.execute(
-                "SELECT value FROM config WHERE key = ?",
-                (label_key,),
-            ).fetchone()
-            if label_row:
-                import json as _json
-                tfidf_labels = _json.loads(dict(label_row)["value"])
-        except Exception:
-            pass
-
-        cluster_colors = [
-            '#667eea', '#764ba2', '#43e97b', '#38f9d7',
-            '#4facfe', '#00f2fe', '#f093fb', '#f5576c',
-            '#fa709a', '#fee140', '#30cfd0', '#330867',
-        ]
-
-        communities = []
-        for row in comm_rows:
-            d = dict(row)
-            comm_id = d["community_id"]
-
-            # Use TF-IDF label if available, else generate inline
-            label = tfidf_labels.get(str(comm_id), "")
-            if not label:
-                # Inline fallback: word frequency from top facts
-                try:
-                    fact_rows = conn.execute(
-                        "SELECT af.content FROM fact_importance fi "
-                        "JOIN atomic_facts af ON fi.fact_id = af.fact_id "
-                        "WHERE fi.profile_id = ? AND fi.community_id = ? "
-                        "ORDER BY fi.pagerank_score DESC LIMIT 20",
-                        (pid, comm_id),
-                    ).fetchall()
-                    from collections import defaultdict as _ddict
-                    wf = _ddict(int)
-                    sw = {"the", "a", "an", "is", "was", "are", "to", "of",
-                          "in", "for", "on", "with", "at", "by", "from",
-                          "and", "but", "or", "not", "it", "this", "that",
-                          "i", "we", "they", "he", "she", "you", "my"}
-                    for fr in fact_rows:
-                        for w in (dict(fr).get("content", "")).lower().split():
-                            w = w.strip(".,;:!?\"'()[]{}")
-                            if len(w) > 2 and w not in sw:
-                                wf[w] += 1
-                    top = sorted(wf.items(), key=lambda x: x[1], reverse=True)[:3]
-                    label = ", ".join(w for w, _ in top) if top else f"Community {comm_id}"
-                except Exception:
-                    label = f"Community {comm_id}"
-
-            # Get top entities from canonical_entities_json
-            top_entities = []
-            try:
-                ent_rows = conn.execute(
-                    "SELECT af.canonical_entities_json FROM fact_importance fi "
-                    "JOIN atomic_facts af ON fi.fact_id = af.fact_id "
-                    "WHERE fi.profile_id = ? AND fi.community_id = ? "
-                    "ORDER BY fi.pagerank_score DESC LIMIT 10",
-                    (pid, comm_id),
-                ).fetchall()
-                import json as _json2
-                entity_counts: dict = {}
-                for er in ent_rows:
-                    raw = dict(er).get("canonical_entities_json", "")
-                    if raw:
-                        try:
-                            for ent in _json2.loads(raw):
-                                entity_counts[ent] = entity_counts.get(ent, 0) + 1
-                        except (ValueError, TypeError):
-                            pass
-                top_entities = sorted(
-                    entity_counts, key=entity_counts.get, reverse=True,
-                )[:5]
-            except Exception:
-                pass
-
-            communities.append({
-                "community_id": comm_id,
-                "label": label,
-                "member_count": d["member_count"],
-                "top_entities": top_entities,
-                "color": cluster_colors[comm_id % len(cluster_colors)],
-                "pagerank_avg": round(float(d["pagerank_avg"] or 0), 4),
-            })
-
-        conn.close()
-        return {"communities": communities, "total": len(communities)}
-
-    except Exception as e:
-        return _internal_error()
-
-
-@router.post("/graph/run-communities")
-async def run_community_detection(request: Request):
-    """Trigger community detection manually (runs GraphAnalyzer)."""
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        from superlocalmemory.storage.database import DatabaseManager
-        from superlocalmemory.storage import schema as _schema
-        from superlocalmemory.core.graph_analyzer import GraphAnalyzer
-
-        pid = get_active_profile()
-        _require_manage_for_profile(request, pid)
-        authorization = authorize_route_mutation(
-            request,
-            operation="update",
-            source_agent_id="http-community-detection",
-            profile_id=pid,
-        )
-        db = DatabaseManager(DB_PATH)
-        db.initialize(_schema)
-
-        analyzer = GraphAnalyzer(db)
-        result = analyzer.compute_and_store(pid)
-        authorization.complete()
-        return {"success": True, **result}
-    except HTTPException:
-        raise
-    except Exception as e:
-        return _internal_error()
-
-
-@router.get("/v33/overview")
-async def v33_overview(request: Request, profile: str = ""):
-    """Get SLM 3.3 feature overview -- all new capabilities at a glance."""
-    pid = _resolve_profile(request, profile)
-    try:
-        from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
-
-        overview: dict = {
-            "version": "3.3",
-            "profile": pid,
-            "forgetting": {"total": 0, "zones": {}},
-            "quantization": {"total": 0, "tiers": {}, "compression_ratio": 1.0},
-            "ccq": {"blocks": 0, "facts_archived": 0},
-            "soft_prompts": {"total": 0, "total_tokens": 0},
-            "hopfield": {
-                "available": False,
-                "description": "Modern Continuous Hopfield Network retrieval channel",
-            },
-            "process_health": {"healthy": True},
-        }
-
-        if not DB_PATH.exists():
-            return overview
-
-        conn = get_read_connection(DB_PATH)
-        conn.row_factory = _sqlite3.Row
-
-        # Forgetting stats
-        try:
-            zones = {"active": 0, "warm": 0, "cold": 0, "archive": 0, "forgotten": 0}
-            rows = conn.execute(
-                "SELECT lifecycle_zone, COUNT(*) AS cnt "
-                "FROM fact_retention WHERE profile_id = ? "
-                "GROUP BY lifecycle_zone",
-                (pid,),
-            ).fetchall()
-            total_fg = 0
-            for row in rows:
-                d = dict(row)
-                zone = d["lifecycle_zone"]
-                if zone in zones:
-                    zones[zone] = d["cnt"]
-                total_fg += d["cnt"]
-            overview["forgetting"] = {"total": total_fg, "zones": zones}
-        except Exception:
-            pass
-
-        # Quantization stats
-        try:
-            tiers = {"float32": 0, "int8": 0, "polar4": 0, "polar2": 0}
-            rows = conn.execute(
-                "SELECT quantization_level, COUNT(*) AS cnt "
-                "FROM embedding_quantization_metadata "
-                "WHERE profile_id = ? GROUP BY quantization_level",
-                (pid,),
-            ).fetchall()
-            total_q = 0
-            for row in rows:
-                d = dict(row)
-                level = d["quantization_level"]
-                if level in tiers:
-                    tiers[level] = d["cnt"]
-                total_q += d["cnt"]
-            overview["quantization"] = {
-                "total": total_q, "tiers": tiers, "compression_ratio": 1.0,
-            }
-        except Exception:
-            pass
-
-        # CCQ stats
-        try:
-            block_count = conn.execute(
-                "SELECT COUNT(*) FROM ccq_consolidated_blocks "
-                "WHERE profile_id = ?", (pid,),
-            ).fetchone()[0]
-            # Count archived facts (lifecycle='archived' from CCQ)
-            archived_count = 0
-            try:
-                archived_count = conn.execute(
-                    "SELECT COUNT(*) FROM atomic_facts "
-                    "WHERE profile_id = ? AND lifecycle = 'archived'",
-                    (pid,),
-                ).fetchone()[0]
-            except Exception:
-                pass
-            overview["ccq"] = {
-                "blocks": block_count,
-                "facts_archived": archived_count,
-            }
-        except Exception:
-            pass
-
-        # Soft prompts stats
-        try:
-            prompt_rows = conn.execute(
-                "SELECT COUNT(*) AS cnt, COALESCE(SUM(token_count), 0) AS tokens "
-                "FROM soft_prompt_templates "
-                "WHERE profile_id = ? AND active = 1",
-                (pid,),
-            ).fetchone()
-            if prompt_rows:
-                d = dict(prompt_rows)
-                overview["soft_prompts"] = {
-                    "total": d["cnt"],
-                    "total_tokens": d["tokens"],
-                }
-        except Exception:
-            pass
-
-        # Hopfield channel availability
-        try:
-            from superlocalmemory.retrieval.hopfield_channel import HopfieldChannel  # noqa: F401
-            overview["hopfield"]["available"] = True
-        except ImportError:
-            pass
-
-        # Process health
-        try:
-            import os as _os
-            _os.kill(_os.getppid(), 0)
-            overview["process_health"] = {"healthy": True}
-        except ProcessLookupError:
-            overview["process_health"] = {"healthy": False}
-        except (PermissionError, OSError):
-            overview["process_health"] = {"healthy": True}
-
-        conn.close()
-        return overview
-    except Exception as e:
-        return _internal_error()
-
-
-# ── MCP Profiles ─────────────────────────────────────────────
-
-@router.get("/mcp/profiles")
-async def get_mcp_profiles(request: Request):
-    """MCP profile summary: current profile, all profiles with tool counts and names.
-
-    Reads only the env var SLM_MCP_PROFILE and the pure-data profiles module.
-    No engine required — safe to call at any point in the daemon lifecycle.
-
-    Note on 'current': when SLM_MCP_PROFILE is unset the MCP server falls
-    back to the legacy _ESSENTIAL_TOOLS set.  The UI reports 'core' for that
-    state because 'core' is the recommended named-profile equivalent for new
-    installs and is the closest documented starting point for users.
-    """
-    try:
-        from superlocalmemory.mcp.profiles import (
-            _PROFILE_DEFINITIONS,
-            _PROFILE_ALIASES,
-            PROFILE_DESCRIPTIONS,
-        )
-
-        raw_profile = os.environ.get("SLM_MCP_PROFILE", "").strip().lower()
-        canonical = _PROFILE_ALIASES.get(raw_profile, raw_profile)
-        # Blank env var, "whole", or an unknown value all resolve to "core"
-        # for UI display purposes (safe, conservative default).
-        if not canonical or canonical == "whole" or canonical not in _PROFILE_DEFINITIONS:
-            current = "core"
-        else:
-            current = canonical
-
-        profiles_out: dict = {}
-        for name, tool_set in _PROFILE_DEFINITIONS.items():
-            profiles_out[name] = {
-                "count": len(tool_set),
-                "tools": sorted(tool_set),
-                "description": PROFILE_DESCRIPTIONS.get(name, ""),
-            }
-
-        all_tools: set = set()
-        for tool_set in _PROFILE_DEFINITIONS.values():
-            all_tools.update(tool_set)
-
-        return {
-            "current": current,
-            "profiles": profiles_out,
-            "aliases": dict(_PROFILE_ALIASES),
-            "total_tools": len(all_tools),
-        }
-    except Exception:
-        return _internal_error()