superlocalmemory 3.8.2 → 3.8.5

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

@@ -596,7 +596,9 @@ def _validate_provider_url(url: str, client_host: str) -> str | None:
     host = p.hostname or ""
     if host.lower() in ("169.254.169.254", "metadata.google.internal", "metadata"):
         return "Cloud metadata endpoints are not allowed"
-    if client_host in ("127.0.0.1", "::1", "localhost"):
+    from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
+
+    if _is_loopback_host(client_host):
         return None  # local dashboard may target its own local/LAN endpoints
     # 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
@@ -1808,7 +1810,7 @@ async def update_core_memory_block(block_id: str, request: Request):
             )
 
         from superlocalmemory.server.routes.helpers import DB_PATH, get_active_profile
-        import sqlite3
+        from superlocalmemory.storage.memory_write import memory_write
         from datetime import datetime, timezone
 
         if not DB_PATH.exists():
@@ -1827,46 +1829,38 @@ async def update_core_memory_block(block_id: str, request: Request):
             content_preview=str(content),
         )
 
-        conn = sqlite3.connect(str(DB_PATH))
-        conn.row_factory = sqlite3.Row
-
-        # 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:
-            conn.close()
-            return JSONResponse(
-                {"error": f"Block {block_id} not found"},
-                status_code=404,
-            )
-
-        existing_dict = dict(existing)
-        new_version = existing_dict["version"] + 1
         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()
 
-        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),
-        )
-        conn.commit()
+            if not existing:
+                raise HTTPException(status_code=404, detail=f"Block {block_id} not found")
 
-        # Read back updated block
-        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()
-        conn.close()
+            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 dict(updated) if updated else {"block_id": block_id, "updated": True}
+        return updated_dict
     except HTTPException:
         raise
     except Exception as e:
@@ -1990,7 +1984,7 @@ async def run_forgetting(request: Request):
         profile = body.get("profile", "")
 
         from superlocalmemory.server.routes.helpers import get_active_profile, DB_PATH
-        import sqlite3 as _sqlite3
+        from superlocalmemory.storage.memory_write import memory_write as _memory_write
         pid = _resolve_mutation_profile(profile)
         _require_manage_for_profile(request, pid)
 
@@ -2003,59 +1997,55 @@ async def run_forgetting(request: Request):
             source_agent_id="http-forgetting-run",
             profile_id=pid,
         )
-        conn = _sqlite3.connect(str(DB_PATH))
-        conn.row_factory = _sqlite3.Row
 
+        # memory_write: process write lock + busy_timeout — all UPDATEs atomic.
         updated = 0
         try:
-            # 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:
+            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 lifecycle_zone = ? "
+                    "SET retention_score = MAX(0.0, retention_score * 0.9), "
+                    "    last_computed_at = datetime('now') "
                     "WHERE profile_id = ? "
-                    "AND retention_score < ? "
                     "AND lifecycle_zone NOT IN ('archive', 'forgotten')",
-                    (zone, pid, threshold),
+                    (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)
+                # 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,),
+                )
 
-            conn.commit()
+                from superlocalmemory.core.lifecycle_state import reconcile_profile_lifecycle
+                reconcile_profile_lifecycle(conn, pid)
         except Exception as exc:
             logger.exception("run_forgetting decay failed")
-            conn.close()
             return {"success": False, "error": "internal error"}
 
-        conn.close()
         authorization.complete()
         return {"success": True, "facts_decayed": updated, "profile": pid}
     except HTTPException:

package/src/superlocalmemory/server/unified_daemon.py

@@ -72,6 +72,22 @@ from superlocalmemory.learning.source_quality import (
     repair_historical_source_quality,
 )
 
+# D-02 fix: import at module load so the reference survives interpreter teardown.
+# A lazy import inside the shutdown path races the namespace-cleanup phase on
+# CPython and can raise ImportError: "cannot import name 'trigram_index'".
+try:
+    from superlocalmemory.learning import trigram_index as _trigram_index_mod
+except ImportError:  # pragma: no cover — defensive for stripped installs
+    _trigram_index_mod = None  # type: ignore[assignment]
+
+# D-03 fix: move this import to module top so the already-compiled .pyc object
+# is used at shutdown time. A lazy import of a source .py during interpreter
+# shutdown on macOS triggers TCC xattr checks and can raise PermissionError.
+try:
+    from superlocalmemory.hooks._outcome_common import _perf_log_flush as _perf_log_flush_fn
+except ImportError:  # pragma: no cover — defensive for stripped installs
+    _perf_log_flush_fn = None  # type: ignore[assignment]
+
 logger = logging.getLogger("superlocalmemory.unified_daemon")
 
 _DEFAULT_PORT = 8765
@@ -453,6 +469,61 @@ def _emit_event(
 import asyncio as _asyncio
 _recall_semaphore = _asyncio.Semaphore(3)
 
+
+def _recall_budget_s() -> float:
+    """Generous latency budget for a recall before the keyword fallback (v3.8.3).
+
+    SLM's value is quality recall under heavy multi-agent load, so semantic
+    recall is given ample time; the keyword fallback is a LAST-RESORT safety
+    net for a genuine hang (e.g. a wedged embedder), not a speed cutoff. Tune
+    with SLM_SEARCH_RECALL_TIMEOUT_S (shared with the dashboard search route).
+    """
+    import os
+    try:
+        v = float(os.environ.get("SLM_SEARCH_RECALL_TIMEOUT_S", ""))
+        return v if v > 0 else 25.0
+    except (TypeError, ValueError):
+        return 25.0
+
+
+def _recall_keyword_fallback(engine, query: str, limit: int) -> dict:
+    """Fast profile-scoped keyword (LIKE) fallback for /recall.
+
+    Used only when semantic recall exceeds its budget, so CLI/MCP callers get
+    a bounded response instead of hanging. Mirrors the dashboard /api/search
+    fallback shape (retrieval_mode=degraded_lexical).
+    """
+    results = []
+    try:
+        rows = engine._db.execute(
+            "SELECT fact_id, content, confidence FROM atomic_facts "
+            "WHERE profile_id = ? AND content LIKE ? "
+            "ORDER BY confidence DESC LIMIT ?",
+            (engine.profile_id, f"%{query}%", limit),
+        )
+        for pos, r in enumerate(rows, start=1):
+            d = dict(r)
+            results.append({
+                "fact_id": d.get("fact_id"),
+                "content": (d.get("content") or "")[:2400],
+                "score": None, "relevance_score": None, "ranking_score": None,
+                "confidence": d.get("confidence"),
+                "rank_position": pos,
+            })
+    except Exception as exc:
+        logger.warning("recall keyword fallback failed (non-fatal): %s", exc)
+    return {
+        "ok": True,
+        "query": query,
+        "query_type": "text_search",
+        "retrieval_mode": "degraded_lexical",
+        "degraded_reason": "recall_budget_exceeded",
+        "result_count": len(results),
+        "results": results,
+        "count": len(results),
+        "no_confident_match": True,
+    }
+
 # v3.4.52: Embedding model warm state. Set to True by the async pre-warm
 # thread once Ollama has loaded the embedding model. /health reports this
 # so MCP clients can wait for warm state before issuing recall calls.
@@ -746,6 +817,29 @@ def _warm_spreading_activation(engine, runtime) -> bool:
                 sa.search(query_embedding, profile_id=active_pid, top_k=7)
         else:
             sa.search(query_embedding, profile_id=active_pid, top_k=7)
+        # v3.8.5: pre-load the per-profile graph-metrics cache (PageRank +
+        # community for every fact) here in the background, so the FIRST real
+        # recall does not pay the ~12k-row load on its hot path.  Observed as a
+        # large chunk of the 8-13s "cold first query" spike: the metrics cache
+        # was loading lazily during the user's first recall instead of at boot.
+        try:
+            sa._load_graph_metrics_cache(active_pid)
+        except Exception:
+            pass
+        # v3.8.5: warm the EntityGraphChannel's in-memory adjacency cache (ALL
+        # ~208K edges + entity maps + graph metrics, ~18 MB) at boot.  This was
+        # the dominant cause of the "cold first query" spike (8-13s): the cache
+        # loaded lazily on the FIRST real recall that routed to the entity
+        # channel, not during warmup.  Force it here via the channel's own
+        # search entry so it is warm before any user query.
+        try:
+            entity_channel = getattr(retr, "_entity", None)
+            if entity_channel is not None:
+                entity_channel.search(
+                    "memory graph adjacency warmup", active_pid, top_k=5,
+                )
+        except Exception:
+            pass
         logger.info(
             "Spreading-activation graph pre-warmed for profile %s", active_pid,
         )
@@ -1307,11 +1401,15 @@ async def lifespan(application: FastAPI):
         # full sort.  Without them full recall takes 7-10s on
         # >1M edges (the SpreadingActivation 4-UNION query disk-sorts every
         # node's neighbor list on each call).  With them: sub-second.
+        #
+        # Concurrency fix (v3.8.4): wrapped in memory_write() so the process
+        # write lock is acquired before the connection is opened.  Previously
+        # the raw sqlite3.connect() bypassed get_write_lock() and had no
+        # busy_timeout, which risked SQLITE_BUSY at daemon startup when other
+        # writers (hook / CLI) were already active.
         try:
-            import sqlite3 as _sqlite3
-            _idx_conn = _sqlite3.connect(str(_memory_db))
-            try:
-                _idx_conn.execute("PRAGMA journal_mode=WAL")
+            from superlocalmemory.storage.memory_write import memory_write as _mw
+            with _mw(_memory_db) as _idx_conn:
                 _idx_conn.execute(
                     "CREATE INDEX IF NOT EXISTS idx_edges_source_weight "
                     "ON graph_edges(profile_id, source_id, weight DESC)"
@@ -1328,10 +1426,6 @@ async def lifespan(application: FastAPI):
                     "CREATE INDEX IF NOT EXISTS idx_assoc_target_weight "
                     "ON association_edges(profile_id, target_fact_id, weight DESC)"
                 )
-            finally:
-                # CP-09: close even if an execute() raises, so the connection
-                # (and its file handle / shared DB lock) never leaks.
-                _idx_conn.close()
         except Exception as _idx_exc:
             logger.debug("SpreadingActivation covering indexes skipped: %s", _idx_exc)
 
@@ -1358,14 +1452,36 @@ async def lifespan(application: FastAPI):
         _embedding_warm = False
         def _warmup_embedder():
             global _embedding_warm
-            try:
-                embedder = getattr(retrieval_eng, '_embedder', None) if retrieval_eng else None
-                if embedder and hasattr(embedder, 'embed'):
-                    embedder.embed("warmup")
-                    _embedding_warm = True
-                    logger.info("Embedding worker pre-warmed (model resident, keep_alive=-1)")
-            except Exception as exc:
-                logger.warning("Embedding warmup failed: %s", exc)
+            import time as _t
+            # RETRY: the retrieval engine / embedder can be created lazily a
+            # moment AFTER this thread starts.  The old one-shot attempt often
+            # captured a None embedder and left _embedding_warm stuck False
+            # forever — so /health reported not-ready even though on-demand
+            # embeds worked.  A stuck not-ready can make an auto-start hook
+            # believe the daemon is down and spawn a DUPLICATE daemon (two
+            # processes writing memory.db → cross-process SQLITE_BUSY).  Poll
+            # until the real embedder (retrieval_eng._embedder, the same one
+            # recall uses) is available, warm it, and flip the flag.
+            for _attempt in range(240):  # ~120s max at 0.5s steps
+                try:
+                    _re = retrieval_eng or getattr(engine, '_retrieval_engine', None)
+                    embedder = getattr(_re, '_embedder', None) if _re else None
+                    if embedder is not None and hasattr(embedder, 'embed'):
+                        embedder.embed("warmup")
+                        _embedding_warm = True
+                        logger.info(
+                            "Embedding worker pre-warmed (model resident, "
+                            "keep_alive=-1)"
+                        )
+                        return
+                except Exception as exc:
+                    logger.debug("Embedding warmup attempt %d failed: %s",
+                                 _attempt, exc)
+                _t.sleep(0.5)
+            logger.warning(
+                "Embedding warmup did not complete after retries; /health "
+                "may report not-ready even though on-demand embeds work"
+            )
 
         def _warmup_recall():
             """v3.4.62: Fire a full recall after embedding warms up.
@@ -1407,6 +1523,20 @@ async def lifespan(application: FastAPI):
                 # v3.8: the --fast recalls above skip spreading activation; warm
                 # that channel directly so the first FULL recall is not cold.
                 _warm_spreading_activation(engine, profile_runtime)
+                # v3.8.5: the fast recalls above do NOT exercise the full ranking
+                # path or the agentic round, so the FIRST real user query that
+                # takes the full path paid an 8-13s cold cost (ranking model +
+                # graph-metrics load).  Fire ONE full (fast=False) recall here in
+                # the background so those load at boot, not on a user's query.
+                # Best-effort; never blocks readiness.
+                try:
+                    with profile_runtime.operation_nowait() as _fsnap:
+                        if _fsnap is not None:
+                            engine.recall(
+                                "memory recall performance", limit=5, fast=False,
+                            )
+                except Exception as _fexc:
+                    logger.debug("Full-path warmup skipped (non-fatal): %s", _fexc)
                 elapsed = round((_t.monotonic() - t0) * 1000)
                 logger.info(
                     "Recall engine pre-warmed in %dms", elapsed,
@@ -1424,6 +1554,11 @@ async def lifespan(application: FastAPI):
             """
             import time as _t
             from pathlib import Path as _P
+            if os.environ.get("SLM_DISABLE_VS_BACKFILL") == "1":
+                logger.info(
+                    "VS backfill disabled via SLM_DISABLE_VS_BACKFILL=1"
+                )
+                return
             for _ in range(120):
                 if _embedding_warm:
                     break
@@ -1455,7 +1590,42 @@ async def lifespan(application: FastAPI):
                         continue
                     if vs.count(pid) >= int(len(with_emb) * 0.98):
                         continue  # already complete — no-op
-                    n = vs.rebuild_from_facts(with_emb)
+                    # Fix: route each upsert through db._lock with cooperative
+                    # yield between facts.  Previously called
+                    # vs.rebuild_from_facts() which opens its own sqlite3
+                    # connection (bypassing db._lock), causing concurrent
+                    # backfill_missing_embeddings writes to hit SQLITE_BUSY
+                    # while holding db._lock — starving user writes for ~50 s.
+                    import os as _selfheal_os
+                    # Stage 2 (write-queue plan): batch upserts so the write lock
+                    # is acquired a FEW times with a clear release window (pause)
+                    # between batches — instead of thousands of rapid
+                    # re-acquisitions.  threading.RLock is NOT fair, so on a
+                    # fresh boot a waiting user /remember could be starved for
+                    # ~50 s behind the per-fact churn.  A real pause between
+                    # bounded batches guarantees the waiting user write wins the
+                    # lock promptly.  One-time backfill; steady state no-ops.
+                    _batch = max(1, int(
+                        _selfheal_os.environ.get("SLM_SELFHEAL_BATCH", "50")))
+                    _pause = max(0.0, float(
+                        _selfheal_os.environ.get("SLM_SELFHEAL_BATCH_PAUSE_S", "0.05")))
+                    n = 0
+                    for _i in range(0, len(with_emb), _batch):
+                        _chunk = with_emb[_i:_i + _batch]
+                        with db._lock:
+                            for _fact_id, _profile_id, _embedding in _chunk:
+                                try:
+                                    if vs.upsert(_fact_id, _profile_id, _embedding):
+                                        n += 1
+                                except Exception as _upsert_exc:
+                                    logger.warning(
+                                        "VS backfill[%s]: upsert failed for %s: %s",
+                                        pid, str(_fact_id)[:16], _upsert_exc,
+                                    )
+                        # Release window: let any waiting user write through
+                        # before grabbing the lock again.
+                        if _pause > 0:
+                            _t.sleep(_pause)
                     logger.info(
                         "VS backfill[%s]: indexed %d of %d embedded facts",
                         pid, n, len(with_emb),
@@ -2101,18 +2271,23 @@ async def lifespan(application: FastAPI):
         logger.warning("evolution cost-conn cache close failed: %s", exc)
 
     # Drop the trigram cache conn symmetrically.
+    # D-02: use module-level reference (_trigram_index_mod) to avoid re-importing
+    # during interpreter teardown when the learning namespace may be gone.
     try:
-        from superlocalmemory.learning import trigram_index as _ti
-        _ti._reset_cache_conn()
+        if _trigram_index_mod is not None:
+            _trigram_index_mod._reset_cache_conn()
     except Exception as exc:  # pragma: no cover — defensive
         logger.warning("trigram cache conn close failed: %s", exc)
 
     # Flush the perf-log fd explicitly (the atexit hook still fires
     # but explicit close here is cheap insurance against uvicorn
     # killing the process before atexit runs).
+    # D-03: use module-level reference (_perf_log_flush_fn) — a lazy import here
+    # triggers macOS TCC xattr checks on the source .py at shutdown time, causing
+    # PermissionError: "Operation not permitted: .../hooks/_outcome_common.py".
     try:
-        from superlocalmemory.hooks._outcome_common import _perf_log_flush
-        _perf_log_flush()
+        if _perf_log_flush_fn is not None:
+            _perf_log_flush_fn()
     except Exception as exc:  # pragma: no cover — defensive
         logger.warning("perf_log flush failed: %s", exc)
 
@@ -2418,7 +2593,33 @@ def _register_dashboard_routes(application: FastAPI) -> None:
 
     Extracted from api.py's create_app() to avoid duplicate MemoryEngine.
     """
-    from superlocalmemory.server.api import UI_DIR
+    from superlocalmemory.server.api import UI_DIR as _source_ui_dir
+
+    # D-04: Copy UI assets to the data dir at daemon startup to avoid macOS
+    # xattr/TCC PermissionError on source-tree files in editable installs.
+    # The data dir has no quarantine attributes; the copy is idempotent (same
+    # content from the same package) so concurrent daemon starts are safe.
+    # Falls back to the source path with a WARNING — never crashes the daemon.
+    import shutil as _shutil
+    _data_ui_dir = state_path("ui")
+    try:
+        _data_ui_dir.mkdir(parents=True, exist_ok=True)
+        if _source_ui_dir.is_dir():
+            _shutil.copytree(
+                str(_source_ui_dir),
+                str(_data_ui_dir),
+                dirs_exist_ok=True,  # idempotent; safe under concurrent starts
+            )
+        UI_DIR = _data_ui_dir
+    except Exception as _ui_copy_exc:
+        # D-04 fallback: source path. Logged as WARNING (not DEBUG) so operators
+        # can diagnose PermissionError on editable installs. Never silently hidden.
+        logger.warning(
+            "D-04: UI copy to data dir failed; serving from source path %s: %s",
+            _source_ui_dir,
+            _ui_copy_exc,
+        )
+        UI_DIR = _source_ui_dir
 
     # Rate limiting (graceful)
     try:
@@ -2468,7 +2669,8 @@ def _register_dashboard_routes(application: FastAPI) -> None:
         async def rate_limit_middleware(request, call_next):
             client_ip = request.client.host if request.client else "unknown"
             is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
-            loopback = client_ip in ("127.0.0.1", "::1")
+            from superlocalmemory.server.loopback import is_loopback as _is_lb_rl
+            loopback = _is_lb_rl(client_ip)
             if not loopback and is_rate_limit_exempt(client_ip):
                 return await call_next(request)
             if loopback:
@@ -2660,10 +2862,17 @@ def _register_dashboard_routes(application: FastAPI) -> None:
             "fallback; non-loopback writes will be rejected.", _auth_exc,
         )
         try:
-            from superlocalmemory.hooks.prewarm_auth import is_loopback as _is_lb
+            from superlocalmemory.server.loopback import is_loopback as _is_lb
         except Exception:
-            def _is_lb(h: str) -> bool:
-                return h in ("127.0.0.1", "::1", "localhost")
+            import ipaddress as _ipa_fb
+
+            def _is_lb(h: str) -> bool:  # type: ignore[misc]
+                if not h or h.lower() == "localhost":
+                    return bool(h)
+                try:
+                    return _ipa_fb.ip_address(h).is_loopback
+                except ValueError:
+                    return False
 
         @application.middleware("http")
         async def _failclosed_auth(request, call_next):
@@ -2679,9 +2888,14 @@ def _register_dashboard_routes(application: FastAPI) -> None:
                 )
             return await call_next(request)
 
-    # Static files
+    # Static files — UI_DIR is already the effective path (data-dir or source
+    # fallback) set by the D-04 copy block above; mkdir is a no-op for
+    # the data-dir path (already created) and guarded in the source-fallback case.
     from fastapi.staticfiles import StaticFiles
-    UI_DIR.mkdir(exist_ok=True)
+    try:
+        UI_DIR.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass  # source path may not be writable; StaticFiles reads, not writes
     application.mount("/static", StaticFiles(directory=str(UI_DIR)), name="static")
 
     # Route modules
@@ -2920,9 +3134,14 @@ def _register_daemon_routes(application: FastAPI) -> None:
         }
         # request is None only for direct internal/test calls (no HTTP client),
         # which are trusted; over HTTP FastAPI always injects the real Request.
+        from superlocalmemory.server.loopback import is_loopback as _is_loopback_host
+        from superlocalmemory.server.write_identity import _TEST_ISOLATION_ALLOWED
+
         client_host = request.client.host if (request and request.client) else ""
-        _trusted = request is None or client_host in (
-            "127.0.0.1", "::1", "localhost", "testclient",
+        _trusted = (
+            request is None
+            or _is_loopback_host(client_host)
+            or (client_host == "testclient" and _TEST_ISOLATION_ALLOWED)
         )
         if not _trusted:
             return public
@@ -3013,15 +3232,35 @@ def _register_daemon_routes(application: FastAPI) -> None:
         if not fast:
             await _recall_semaphore.acquire()
         try:
-            response = await asyncio.to_thread(
-                engine.recall,
-                search_query, limit=limit, session_id=effective_sid,
-                agent_id=recall_actor,
-                fast=fast,
-                include_global=include_global,
-                include_shared=include_shared,
-                window=window or None,
+            # v3.8.3: bound the recall so CLI/MCP callers never hang on a
+            # wedged embedder. Poll the executor future (which cannot be
+            # cancelled) without blocking the loop, and give quality recall a
+            # GENEROUS budget; only if it is exceeded do we serve the fast
+            # keyword fallback. The orphaned recall finishes in the background.
+            loop = asyncio.get_running_loop()
+            _rf = loop.run_in_executor(
+                None,
+                lambda: engine.recall(
+                    search_query, limit=limit, session_id=effective_sid,
+                    agent_id=recall_actor,
+                    fast=fast,
+                    include_global=include_global,
+                    include_shared=include_shared,
+                    window=window or None,
+                ),
             )
+            _budget = _recall_budget_s()
+            _deadline = loop.time() + _budget
+            while not _rf.done() and loop.time() < _deadline:
+                await asyncio.sleep(0.05)
+            if not _rf.done():
+                _rf.add_done_callback(lambda f: (f.cancelled() or f.exception()))
+                logger.warning(
+                    "recall: semantic recall exceeded %.0fs budget for %r — "
+                    "serving keyword fallback", _budget, (search_query or "")[:80],
+                )
+                return _recall_keyword_fallback(engine, search_query, limit)
+            response = _rf.result()
             # v3.4.26: return the same field shape as recall_worker so
             # MCP processes proxying through the daemon get recall_trace-
             # compatible data without a second round trip.
@@ -3932,7 +4171,12 @@ def start_server(port: int = _DEFAULT_PORT) -> None:
             "reachable from the network but SLM_REQUIRE_CREDENTIALS is not set "
             "and API-key auth may be off. A remote caller could write without "
             "credentials. Set SLM_REQUIRE_CREDENTIALS=1 and configure an API "
-            "key before exposing this instance.", bind_host,
+            "key before exposing this instance. "
+            "NOTE (issue #90): SLM 3.8.4 fixes IPv4-mapped loopback address "
+            "normalization — if curl/dashboard writes fail with 403 from a "
+            "container, upgrade to 3.8.4. Immediate workaround: set "
+            "SLM_DAEMON_HOST=127.0.0.1 (IPv4 only) or configure an API key.",
+            bind_host,
         )
     listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     # This handles a just-closed connection in TIME_WAIT.  It is safe only