superlocalmemory 3.7.7__tar.gz → 3.7.8__tar.gz

{superlocalmemory-3.7.7/src/superlocalmemory.egg-info → superlocalmemory-3.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.7.7
+Version: 3.7.8
 Summary: Local-first agent memory with auditable hybrid retrieval
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License-Expression: AGPL-3.0-or-later
@@ -66,7 +66,6 @@ Requires-Dist: optimum==2.1.0; extra == "search"
 Requires-Dist: einops==0.8.2; extra == "search"
 Requires-Dist: torch==2.11.0; extra == "search"
 Requires-Dist: scikit-learn==1.8.0; extra == "search"
-Requires-Dist: geoopt>=0.5.0; extra == "search"
 Requires-Dist: onnxruntime==1.24.4; extra == "search"
 Provides-Extra: ui
 Requires-Dist: fastapi[all]>=0.135.1; extra == "ui"
@@ -107,10 +106,10 @@ Dynamic: license-file
   </picture>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.7.7</h1>
+<h1 align="center">SuperLocalMemory V3.7.8</h1>
 <p align="center"><strong>Cache. Compress. Remember. Three surfaces — proxy, MCP tools, or skill. Every setup covered.</strong><br/>
 <em>Local-first agent memory with explicit operating modes, auditable retrieval, and optional Optimize tools.</em></p>
-<p align="center"><code>v3.7.7</code> — <strong>Daemon-aware profile isolation, atomic runtime configuration, and verified migration integrity.</strong><br/>
+<p align="center"><code>v3.7.8</code> — <strong>Profile-isolation leak fix, opt-in loopback write auth, and fresh-install acceptance verification.</strong><br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/README.md

@@ -5,10 +5,10 @@
   </picture>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.7.7</h1>
+<h1 align="center">SuperLocalMemory V3.7.8</h1>
 <p align="center"><strong>Cache. Compress. Remember. Three surfaces — proxy, MCP tools, or skill. Every setup covered.</strong><br/>
 <em>Local-first agent memory with explicit operating modes, auditable retrieval, and optional Optimize tools.</em></p>
-<p align="center"><code>v3.7.7</code> — <strong>Daemon-aware profile isolation, atomic runtime configuration, and verified migration integrity.</strong><br/>
+<p align="center"><code>v3.7.8</code> — <strong>Profile-isolation leak fix, opt-in loopback write auth, and fresh-install acceptance verification.</strong><br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.7.7"
+version = "3.7.8"
 description = "Local-first agent memory with auditable hybrid retrieval"
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -97,7 +97,6 @@ search = [
     "einops==0.8.2",
     "torch==2.11.0",
     "scikit-learn==1.8.0",
-    "geoopt>=0.5.0",
     "onnxruntime==1.24.4",
 ]
 ui = [

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/__init__.py

@@ -32,7 +32,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.7.7"
+__version__ = "3.7.8"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/cli/commands.py

@@ -1999,7 +1999,7 @@ def cmd_doctor(args: Namespace) -> None:
 
     # 3. Search deps
     search_mods = {"sentence_transformers": "sentence-transformers", "torch": "torch",
-                   "sklearn": "scikit-learn", "geoopt": "geoopt"}
+                   "sklearn": "scikit-learn"}
     search_ok = []
     for mod, pkg in search_mods.items():
         try:
@@ -2008,7 +2008,7 @@ def cmd_doctor(args: Namespace) -> None:
         except Exception:  # dependency import may fail after module discovery
             pass
     if len(search_ok) == len(search_mods):
-        _check("Search deps", "PASS", "sentence-transformers, torch, sklearn, geoopt")
+        _check("Search deps", "PASS", "sentence-transformers, torch, sklearn")
     else:
         missing = set(search_mods) - set(search_ok)
         _check("Search deps", "WARN", f"Missing: {', '.join(missing)}",

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/infra/auth_middleware.py

@@ -15,6 +15,7 @@ V3 change: base directory moved from ``~/.claude-memory/`` to
 import hashlib
 import hmac
 import logging
+import os
 from pathlib import Path
 from typing import Optional
 
@@ -26,6 +27,13 @@ logger = logging.getLogger("superlocalmemory.auth")
 MEMORY_DIR = DynamicStatePath()
 API_KEY_FILE = DynamicStatePath("api_key")
 
+# v3.7.8 (F1): opt-in env flag that restores the pre-v3.7.6 shared-host
+# posture -- when set AND an api_key file is configured, uncredentialed
+# loopback writes must also present a matching X-SLM-API-Key. Default OFF
+# preserves the v3.7.6 local-first fix (#71/#73/#74): loopback callers are
+# trusted as the local OS-user boundary without needing any credential.
+SLM_REQUIRE_API_KEY_LOOPBACK_ENV = "SLM_REQUIRE_API_KEY_LOOPBACK"
+
 
 def _load_api_key_hash(key_file: Optional[Path] = None) -> Optional[str]:
     """Load and hash the API key from disk.
@@ -96,6 +104,26 @@ def verify_api_key(
     return hmac.compare_digest(actual, expected)
 
 
+def loopback_strict_mode_enabled(key_file: Optional[Path] = None) -> bool:
+    """Whether uncredentialed loopback writes must present the API key.
+
+    v3.7.8 (F1/F2): opt-in via ``SLM_REQUIRE_API_KEY_LOOPBACK`` (any of
+    "1"/"true"/"yes"/"on", case-insensitive). This is the sole enforcement
+    point for the strict shared-host posture -- it is checked ONLY for the
+    uncredentialed-loopback case (a caller presenting none of
+    X-SLM-Daemon-Capability / X-Install-Token / X-SLM-API-Key). Callers who
+    already present a valid capability or install token are unaffected: those
+    are stronger, explicit credentials and this flag never re-litigates them.
+
+    Returns ``False`` (no-op) when the flag is unset/false, OR when no
+    api_key file is configured -- there is nothing to require in that case.
+    """
+    raw = os.environ.get(SLM_REQUIRE_API_KEY_LOOPBACK_ENV, "")
+    if raw.strip().lower() not in ("1", "true", "yes", "on"):
+        return False
+    return _load_api_key_hash(key_file) is not None
+
+
 def authorize_http_mcp_request(
     request_headers: dict,
     *,

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/mcp/tools_core.py

@@ -587,6 +587,10 @@ def register_core_tools(server, get_engine: Callable) -> None:
             )
 
             generation = 0
+            # Only the profile_id explicitly confirmed by this process
+            # (daemon-acknowledged + locally-validated, or locally
+            # validated directly) is ever synced into engine state.
+            confirmed_profile_id = None
             if await asyncio.to_thread(is_daemon_running):
                 result = await asyncio.to_thread(
                     daemon_request,
@@ -599,12 +603,35 @@ def register_core_tools(server, get_engine: Callable) -> None:
                         "error": "resident daemon rejected the profile switch",
                     }
                 acknowledged = str(result.get("active_profile", ""))
-                if acknowledged != profile_id:
+                if not acknowledged or acknowledged != profile_id:
                     return {
                         "success": False,
                         "error": "resident daemon acknowledged a different profile",
                     }
+                # Local consistency guard (SEC-H-01): the daemon's HTTP
+                # acknowledgement alone is not sufficient — this MCP
+                # process must also confirm the profile exists in its
+                # own local DB handle before syncing local state to it.
+                # Mirrors the existence check the no-daemon branch already
+                # performs below.
+                local_rows = engine._db.execute(
+                    "SELECT 1 FROM profiles WHERE profile_id = ?",
+                    (profile_id,),
+                )
+                if not local_rows:
+                    return {
+                        "success": False,
+                        "error": (
+                            f"resident daemon acknowledged profile "
+                            f"'{acknowledged}' but it does not exist in "
+                            f"this process's local profile store"
+                        ),
+                    }
                 generation = int(result.get("generation", 0))
+                # Sync target is the DAEMON-CONFIRMED value, never the raw
+                # caller-supplied profile_id, even though they are equal
+                # here by construction (checked above).
+                confirmed_profile_id = acknowledged
             else:
                 rows = engine._db.execute(
                     "SELECT 1 FROM profiles WHERE profile_id = ?",
@@ -628,10 +655,21 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     engine._config.active_profile = old
                     persistence.rollback()
                     raise
+                confirmed_profile_id = profile_id
+
+            if not confirmed_profile_id:
+                # Defensive: should be unreachable — every path above
+                # either returns an error or sets confirmed_profile_id.
+                return {
+                    "success": False,
+                    "error": "profile switch could not be confirmed",
+                }
 
-            # Synchronize this MCP process only after daemon acknowledgement.
-            engine.profile_id = profile_id
-            engine._config.active_profile = profile_id
+            # Synchronize this MCP process only after confirmation
+            # (daemon-acknowledged + locally-validated, or directly
+            # locally-validated in the no-daemon branch above).
+            engine.profile_id = confirmed_profile_id
+            engine._config.active_profile = confirmed_profile_id
 
             # v3.6.12 (search-3): recall/delete run in a separate worker
             # subprocess that caches its engine (and profile_id) at init. Recycle

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/api.py

@@ -6,6 +6,23 @@
 SuperLocalMemory V3 - FastAPI API Server
 Provides REST endpoints for memory visualization and exploration.
 Uses V3 MemoryEngine for all operations.
+
+v3.7.8 (WS3 F4): ``create_app()`` in this module is a standalone/legacy app
+factory. The running daemon serves ``superlocalmemory.server.unified_daemon:
+create_app`` (see ``unified_daemon.py``'s uvicorn config); THIS factory is
+reachable only via direct ``python -m superlocalmemory.server.api`` /
+programmatic use and the tests that exercise it directly
+(``tests/test_api/test_api_lifespan_contract.py``,
+``tests/test_security/test_rate_limit_e2e.py``). Its ``auth_middleware``
+below intentionally keeps the older, simpler ``check_api_key``-only gate
+(unconditional per-write check, no daemon-capability / install-token
+identity layer) because it predates and is independent of the unified
+daemon's richer ``write_identity.require_http_mutation_actor`` boundary and
+the ``SLM_REQUIRE_API_KEY_LOOPBACK`` opt-in (see
+``infra/auth_middleware.py``). Do not treat this module's auth posture as
+the production write boundary -- that is ``unified_daemon.py``'s
+``auth_middleware``. ``UI_DIR`` below is still imported by
+``unified_daemon.py`` and must not be removed.
 """
 
 import json

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/routes/chat.py

@@ -76,7 +76,7 @@ async def chat_stream(request: Request):
     limit = min(body.get("limit", 10), 20)
 
     return StreamingResponse(
-        _stream_chat(query, mode, limit),
+        _stream_chat(request.app.state, query, mode, limit),
         media_type="text/event-stream",
         headers={
             "Cache-Control": "no-cache",
@@ -89,15 +89,18 @@ async def chat_stream(request: Request):
 # ── Core Chat Logic ──────────────────────────────────────────────
 
 async def _stream_chat(
-    query: str, mode: str, limit: int,
+    app_state, query: str, mode: str, limit: int,
 ) -> AsyncGenerator[str, None]:
     """Retrieve memories, then stream LLM response with citations."""
 
-    # Step 1: Retrieve memories via WorkerPool (run in executor to avoid blocking)
+    # Step 1: Retrieve memories via the daemon's resident engine (run in
+    # executor to avoid blocking the event loop).
     memories = []
     try:
         loop = asyncio.get_event_loop()
-        memories = await loop.run_in_executor(None, _recall_memories, query, limit)
+        memories = await loop.run_in_executor(
+            None, _recall_memories, app_state, query, limit,
+        )
     except Exception as exc:
         yield _sse_event("error", json.dumps({"message": f"Retrieval failed: {exc}"}))
         yield _sse_event("done", "")
@@ -314,14 +317,62 @@ async def _stream_openai_compat(
 
 # ── Retrieval Helper ─────────────────────────────────────────────
 
-def _recall_memories(query: str, limit: int) -> list:
-    """Run full recall via WorkerPool (synchronous, runs in executor)."""
-    from superlocalmemory.core.worker_pool import WorkerPool
-    pool = WorkerPool.shared()
-    result = pool.recall(query, limit=limit)
-    if result.get("ok"):
-        return result.get("results", [])
-    return []
+def _recall_memories(app_state, query: str, limit: int) -> list:
+    """Run full recall via the daemon's resident, lease-protected engine.
+
+    v3.7.8 CRITICAL fix: this used to go through ``WorkerPool.shared()``, a
+    long-lived subprocess that caches its OWN ``MemoryEngine`` + profile_id
+    at process init and is never recycled on a profile switch. That meant a
+    switch could serve the OLD profile's memories to this chat endpoint for
+    up to 120s — a cross-profile data leak. ``application.state.engine`` is
+    rebound synchronously by ``commit_daemon_profile_switch``, so reading it
+    (via the queue-consumer's engine adapter, which already holds the same
+    profile-runtime lease the daemon's own ``/recall`` route uses) always
+    reflects the current profile.
+    """
+    adapter = getattr(app_state, "engine_recall_adapter", None)
+    if adapter is not None:
+        result = adapter.recall(query, limit=limit)
+        if result.get("ok"):
+            return result.get("results", [])
+        return []
+    # Fallback (adapter unavailable, e.g. queue-consumer failed to start):
+    # recall directly against the resident engine under the same profile
+    # lease the HTTP /recall route uses. Never fall back to WorkerPool —
+    # that reintroduces the stale-profile leak this fix closes.
+    return _recall_via_resident_engine(app_state, query, limit)
+
+
+def _recall_via_resident_engine(app_state, query: str, limit: int) -> list:
+    """Lease-protected direct-engine recall, mirroring the /recall route."""
+    from superlocalmemory.server.profile_runtime import get_profile_runtime
+    from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+    runtime = get_profile_runtime(app_state)
+    with runtime.operation():
+        engine = get_engine_lazy(app_state)
+        if engine is None:
+            return []
+        response = engine.recall(query, limit=limit)
+        memory_ids = list({
+            r.fact.memory_id for r in response.results[:limit]
+            if r.fact.memory_id
+        })
+        memory_map = (
+            engine._db.get_memory_content_batch(memory_ids) if memory_ids else {}
+        )
+        from superlocalmemory.server.recall_serializer import (
+            serialize_recall_response,
+        )
+        _rc = getattr(engine._config, "retrieval", None)
+        results, _no_confident_match = serialize_recall_response(
+            response,
+            limit=limit,
+            memory_map=memory_map,
+            per_fact_max=getattr(_rc, "recall_per_fact_max_chars", 2400),
+            total_max=getattr(_rc, "recall_total_max_chars", 12000),
+        )
+        return results
 
 
 # ── SSE Formatting ───────────────────────────────────────────────

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/routes/memories.py

@@ -662,14 +662,28 @@ async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Que
         if not members:
             raise HTTPException(status_code=404, detail="Cluster not found")
         # Generate cluster summary
+        # v3.7.8: previously routed through WorkerPool.shared(), a subprocess
+        # cache never recycled on a profile switch (CRITICAL cross-profile
+        # leak — up to 120s stale). Use the daemon's own resident,
+        # lease-protected engine's config instead; the summarizer only
+        # consumes already profile-filtered `texts` above, so this closes
+        # the stale-engine window without changing behavior.
         summary = ""
         try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            pool = WorkerPool.shared()
             texts = [m.get("content", "")[:200] for m in members[:10] if m.get("content")]
             if texts:
-                result = pool.summarize(texts)
-                summary = result.get("summary", "") if result.get("ok") else ""
+                from superlocalmemory.core.summarizer import Summarizer
+                from superlocalmemory.server.profile_runtime import get_profile_runtime
+                from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+                runtime = get_profile_runtime(request.app.state)
+                with runtime.operation():
+                    engine = get_engine_lazy(request.app.state)
+                    if engine is not None:
+                        summarizer = Summarizer(engine._config)
+                        summary = summarizer.summarize_cluster(
+                            [{"content": t} for t in texts]
+                        ) or ""
         except Exception:
             pass
 
@@ -687,14 +701,47 @@ async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Que
 
 @router.get("/api/memories/{memory_id}/facts")
 async def get_memory_facts(request: Request, memory_id: str):
-    """Get original memory text with all its child atomic facts."""
+    """Get original memory text with all its child atomic facts.
+
+    v3.7.8: previously routed through WorkerPool.shared(), a subprocess
+    engine cached at process init and never recycled on a profile switch
+    (CRITICAL cross-profile leak — served the OLD profile's facts for up to
+    120s after a switch). Uses the daemon's own resident, lease-protected
+    engine instead, exactly like the /recall route.
+    """
     try:
-        from superlocalmemory.core.worker_pool import WorkerPool
-        pool = WorkerPool.shared()
-        result = pool.get_memory_facts(memory_id)
-        if result.get("ok"):
-            return result
-        raise HTTPException(status_code=404, detail="Memory not found")
+        from superlocalmemory.server.profile_runtime import get_profile_runtime
+        from superlocalmemory.server.routes.helpers import get_engine_lazy
+
+        runtime = get_profile_runtime(request.app.state)
+        with runtime.operation():
+            engine = get_engine_lazy(request.app.state)
+            if engine is None:
+                raise HTTPException(status_code=503, detail="Engine not initialized")
+            active_profile = engine.profile_id
+            mem_map = engine._db.get_memory_content_batch([memory_id])
+            original = mem_map.get(memory_id, "")
+            facts = engine._db.get_facts_by_memory_id(memory_id, active_profile)
+        fact_list = [
+            {
+                "fact_id": f.fact_id,
+                "content": f.content,
+                "fact_type": (
+                    f.fact_type.value if hasattr(f.fact_type, "value")
+                    else str(f.fact_type)
+                ),
+                "confidence": round(f.confidence, 3),
+                "created_at": f.created_at,
+            }
+            for f in facts
+        ]
+        return {
+            "ok": True,
+            "memory_id": memory_id,
+            "original_content": original,
+            "facts": fact_list,
+            "fact_count": len(fact_list),
+        }
     except HTTPException:
         raise
     except Exception as e:

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/routes/v3_api.py

@@ -1462,7 +1462,8 @@ async def trigger_consolidation(request: Request):
     """Trigger consolidation manually.
 
     Body: {"lightweight": false, "profile": ""}
-    Uses WorkerPool for thread safety (Rule 18).
+    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()
@@ -1478,44 +1479,42 @@ async def trigger_consolidation(request: Request):
             profile_id=pid,
         )
 
-        # Use WorkerPool to run consolidation in the worker subprocess (Rule 18)
-        try:
-            from superlocalmemory.core.worker_pool import WorkerPool
-            pool = WorkerPool.shared()
-            result = pool.send_command({
-                "action": "consolidate",
-                "profile_id": pid,
-                "lightweight": lightweight,
-            })
-            if result and result.get("ok"):
-                authorization.complete()
-                return {"success": True, **result}
-        except Exception:
-            pass
-
-        # Fallback: direct consolidation if WorkerPool unavailable
+        # v3.7.8 SEC-M-01: the prior "WorkerPool" fast path called
+        # ``pool.send_command(...)``, a method that does not exist on
+        # WorkerPool — every call raised AttributeError, was silently
+        # swallowed by the bare ``except``, and fell through to this direct
+        # path unconditionally. That dead branch is removed; consolidation
+        # always runs directly against a lease-protected DB connection so a
+        # concurrent profile switch cannot commit mid-consolidation.
         from superlocalmemory.core.config import SLMConfig
         from superlocalmemory.storage.database import DatabaseManager
         from superlocalmemory.storage import schema as _schema
         from superlocalmemory.core.consolidation_engine import ConsolidationEngine
+        from superlocalmemory.server.profile_runtime import get_profile_runtime
 
-        config = SLMConfig.load()
-        db = DatabaseManager(config.db_path)
-        db.initialize(_schema)
+        runtime = get_profile_runtime(request.app.state)
+        with runtime.operation():
+            config = SLMConfig.load()
+            db = DatabaseManager(config.db_path)
+            db.initialize(_schema)
 
-        engine = ConsolidationEngine(db=db, config=config.consolidation, slm_config=config)
-        result = engine.consolidate(profile_id=pid, lightweight=lightweight)
+            engine = ConsolidationEngine(
+                db=db, config=config.consolidation, slm_config=config,
+            )
+            result = engine.consolidate(profile_id=pid, lightweight=lightweight)
 
-        # v3.4.1: Auto-trigger behavioral pattern mining after consolidation
-        try:
-            from superlocalmemory.learning.consolidation_worker import ConsolidationWorker
-            learning_db = config.base_dir / "learning.db"
-            cw = ConsolidationWorker(str(config.db_path), str(learning_db))
-            pattern_count = cw._generate_patterns(pid, False)
-            result["patterns_mined"] = pattern_count
-            logger.info("Auto-mined %d patterns after consolidation", pattern_count)
-        except Exception as exc:
-            logger.debug("Pattern mining after consolidation failed: %s", exc)
+            # v3.4.1: Auto-trigger behavioral pattern mining after consolidation
+            try:
+                from superlocalmemory.learning.consolidation_worker import (
+                    ConsolidationWorker,
+                )
+                learning_db = config.base_dir / "learning.db"
+                cw = ConsolidationWorker(str(config.db_path), str(learning_db))
+                pattern_count = cw._generate_patterns(pid, False)
+                result["patterns_mined"] = pattern_count
+                logger.info("Auto-mined %d patterns after consolidation", pattern_count)
+            except Exception as exc:
+                logger.debug("Pattern mining after consolidation failed: %s", exc)
 
         authorization.complete()
         return {"success": True, **result}

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/ui.py

@@ -15,6 +15,16 @@ All route handlers live in routes/ directory:
     routes/events.py    -- /events/stream (SSE), /api/events [v2.5]
     routes/agents.py    -- /api/agents, /api/trust [v2.5]
     routes/ws.py        -- /ws/updates (WebSocket)
+
+v3.7.8 (WS3 F4): ``create_app()`` in this module is a standalone/legacy app
+factory, NOT the app the running daemon serves -- that is
+``superlocalmemory.server.unified_daemon:create_app`` (see that module's
+uvicorn config). This module's ``auth_middleware`` keeps the older,
+unconditional ``check_api_key``-only write gate (no daemon-capability /
+install-token identity layer, no ``SLM_REQUIRE_API_KEY_LOOPBACK`` opt-in --
+see ``infra/auth_middleware.py`` for that). Treat this file as a standalone
+entry point only; the production write-auth boundary lives in
+``unified_daemon.py``.
 """
 
 import logging

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/server/unified_daemon.py

@@ -1726,6 +1726,7 @@ def _register_dashboard_routes(application: FastAPI) -> None:
         from superlocalmemory.infra.auth_middleware import (
             authorize_http_mcp_request,
             check_api_key,
+            loopback_strict_mode_enabled,
         )
         from superlocalmemory.server.write_identity import (
             require_http_mutation_actor,
@@ -1801,25 +1802,52 @@ def _register_dashboard_routes(application: FastAPI) -> None:
                             content={"error": str(_identity_exc.detail)},
                         )
                     raise
-            # v3.7.6 (#71/#73/#74): require_http_mutation_actor above is the
-            # authoritative write-auth boundary — it accepts the daemon
-            # capability, the dashboard install token, a matching X-SLM-API-Key,
-            # or an uncredentialed loopback caller, and fails closed for everyone
-            # else. The legacy check_api_key gate only understands X-SLM-API-Key,
-            # so running it as a second gate 401'd write paths that stage 1 had
-            # already authorized: capability-authenticated daemon write-throughs
-            # (MCP `remember`, #71) and install-token dashboard writes / config
-            # tests (#73/#74) whenever an api_key file exists. Only fall back to
-            # check_api_key when the mutation-actor gate did not run — i.e. for
-            # non-write, non-recall requests, where it is a no-op for reads.
-            if not requires_mutation_actor and not check_api_key(
-                headers, is_write=is_write
-            ):
-                from fastapi.responses import JSONResponse
-                return JSONResponse(
-                    status_code=401,
-                    content={"error": "Invalid or missing API key."},
-                )
+                # v3.7.6 (#71/#73/#74): require_http_mutation_actor above is
+                # the authoritative write-auth boundary — it accepts the
+                # daemon capability, the dashboard install token, a matching
+                # X-SLM-API-Key, or an uncredentialed loopback caller, and
+                # fails closed for everyone else. Running check_api_key as an
+                # unconditional second gate used to 401 write paths stage 1
+                # had already authorized: capability-authenticated daemon
+                # write-throughs (MCP `remember`, #71) and install-token
+                # dashboard writes / config tests (#73/#74) whenever an
+                # api_key file existed.
+                #
+                # v3.7.8 (F1/F2): that fix silently narrowed the api_key
+                # feature — a configured api_key file used to force even
+                # loopback writes to present a credential; after #71/#73/#74
+                # loopback writes need none, with no opt-back-in. This is the
+                # single enforcement point for the opt-in strict posture
+                # (SLM_REQUIRE_API_KEY_LOOPBACK): re-run check_api_key, but
+                # ONLY for the uncredentialed-loopback case — a caller who
+                # presented none of the three credential headers above and
+                # was authorized purely by being loopback. Credentialed
+                # callers (capability / install token / api key) were already
+                # validated by require_http_mutation_actor and are never
+                # re-gated here, so #71/#73/#74 stay fixed.
+                if loopback_strict_mode_enabled():
+                    _has_credential = any(
+                        headers.get(_h)
+                        for _h in (
+                            "x-slm-daemon-capability",
+                            "x-install-token",
+                            "x-slm-api-key",
+                        )
+                    )
+                    if not _has_credential and not check_api_key(
+                        headers, is_write=True
+                    ):
+                        from fastapi.responses import JSONResponse
+                        return JSONResponse(
+                            status_code=401,
+                            content={
+                                "error": (
+                                    "SLM_REQUIRE_API_KEY_LOOPBACK is set: "
+                                    "loopback writes must present a matching "
+                                    "X-SLM-API-Key."
+                                )
+                            },
+                        )
             return await call_next(request)
     except Exception as _auth_exc:
         # v3.6.12 (failopen-1): security middleware must NEVER fail open silently.

{superlocalmemory-3.7.7 → superlocalmemory-3.7.8}/src/superlocalmemory/storage/schema_v32.py

@@ -365,15 +365,6 @@ V32_DDL: list[str] = [
     """,
 ]
 
-# vec0 virtual table DDL — executed by VectorStore ONLY (requires extension loaded first).
-# NOT in V32_DDL because executescript cannot load extensions mid-script.
-V32_VEC0_DDL: Final[str] = """
-CREATE VIRTUAL TABLE IF NOT EXISTS fact_embeddings USING vec0(
-    profile_id TEXT PARTITION KEY,
-    embedding float[768] distance_metric=cosine
-);
-"""
-
 # ---------------------------------------------------------------------------
 # Rollback DDL (reverse FK order -- Rule 20)
 # ---------------------------------------------------------------------------