superlocalmemory 3.8.3 → 3.8.6

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
@@ -367,6 +383,18 @@ def _hot_reconfigure_engine(application, new_config, *, mode_change: bool) -> No
         new_engine.close()
         raise
 
+    canonical_remember = getattr(
+        application.state,
+        "canonical_remember_runtime",
+        None,
+    )
+    if canonical_remember is not None:
+        try:
+            canonical_remember.rebind_engine(new_engine)
+        except BaseException:
+            new_engine.close()
+            raise
+
     # The profile transition barrier is exclusive here. Publish every
     # long-lived reference before closing the former engine.
     application.state.engine = new_engine
@@ -801,6 +829,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,
         )
@@ -1166,6 +1217,25 @@ async def _cancel_source_quality_repair(application) -> None:
         pass
 
 
+def _release_canonical_remember_runtime(application, runtime=None) -> bool:
+    """Release the writer lease without discarding a still-running runtime."""
+    runtime = (
+        runtime
+        if runtime is not None
+        else getattr(application.state, "canonical_remember_runtime", None)
+    )
+    if runtime is None:
+        return True
+    try:
+        runtime.stop()
+    except Exception as exc:  # pragma: no cover - cleanup must continue
+        logger.warning("canonical remember writer shutdown failed: %s", exc)
+        return False
+    if getattr(application.state, "canonical_remember_runtime", None) is runtime:
+        application.state.canonical_remember_runtime = None
+    return True
+
+
 @asynccontextmanager
 async def lifespan(application: FastAPI):
     """Initialize engine, workers, and optional services on startup."""
@@ -1173,6 +1243,7 @@ async def lifespan(application: FastAPI):
 
     engine = None
     config = None
+    canonical_remember_runtime = None
 
     # The local dashboard obtains its short-lived browser credential from
     # ``/internal/token`` before its first write or token-gated read.  A
@@ -1288,6 +1359,17 @@ async def lifespan(application: FastAPI):
         engine = MemoryEngine(config)
         engine.initialize()
 
+        # 3.8.6 canonical remember boundary. Migrations have already created
+        # the immutable receipt ledger and engine init has created the runtime
+        # tables. Claim the daemon's writer lease, install the typed admission
+        # handler, and replay crash-surviving journal entries *before* any
+        # background writer or ready descriptor is published.
+        from superlocalmemory.core.remember_runtime import CanonicalRememberRuntime
+
+        canonical_remember_runtime = CanonicalRememberRuntime.for_engine(engine)
+        canonical_remember_runtime.start()
+        application.state.canonical_remember_runtime = canonical_remember_runtime
+
         # WAL is already established at DB creation (DatabaseManager._enable_wal
         # / schema init). Re-asserting PRAGMA journal_mode=WAL here is a
         # schema-level write on the shared connection that raced in-flight
@@ -1362,11 +1444,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)"
@@ -1383,10 +1469,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)
 
@@ -1413,14 +1495,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.
@@ -1462,6 +1566,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,
@@ -1479,6 +1597,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
@@ -1510,7 +1633,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),
@@ -1757,6 +1915,9 @@ async def lifespan(application: FastAPI):
 
     except Exception:
         logger.exception("Engine init failed")  # auto-includes traceback
+        _release_canonical_remember_runtime(
+            application, canonical_remember_runtime,
+        )
         application.state.engine = None
         application.state.config = None
 
@@ -2156,25 +2317,31 @@ 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)
 
     materializer_stopped = _stop_pending_materializer()
+    canonical_writer_stopped = _release_canonical_remember_runtime(application)
     _profile_runtime = None
     _engine = None
-    if engine is not None and materializer_stopped:
+    if engine is not None and materializer_stopped and canonical_writer_stopped:
         try:
             engine.close()
         except Exception:
@@ -2184,7 +2351,8 @@ async def lifespan(application: FastAPI):
         # object still owned by an admitted background operation; OS process
         # teardown is safer than racing that writer with engine.close().
         logger.warning(
-            "Engine close deferred because pending materializer is still active"
+            "Engine close deferred because a write-capable background component "
+            "is still active"
         )
     _cleanup_process_descriptor(
         getattr(application.state, "daemon_descriptor", None),
@@ -2473,7 +2641,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:
@@ -2523,7 +2717,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:
@@ -2715,10 +2910,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):
@@ -2734,9 +2936,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
@@ -2928,6 +3135,12 @@ def _register_daemon_routes(application: FastAPI) -> None:
     @application.get("/health")
     async def health(request: Request = None):
         _update_activity()
+        try:
+            from superlocalmemory.server.recall_health import get_recall_health
+
+            recall_health = get_recall_health()
+        except Exception:
+            recall_health = {"recall_healthy": None}
         # Non-blocking peek: report status without forcing a re-init.
         engine = getattr(application.state, "engine", None)
         migration_result = getattr(application.state, "migration_result", None)
@@ -2938,24 +3151,40 @@ def _register_daemon_routes(application: FastAPI) -> None:
         migrations_ready = bool(migration_result) and not migration_failures
         if migration_details.get("_crash"):
             migrations_ready = False
+        writer_runtime = getattr(
+            application.state,
+            "canonical_remember_runtime",
+            None,
+        )
         readiness = {
             "engine": engine is not None,
             "migrations": migrations_ready,
-            "retrieval": bool(_embedding_warm),
+            "writer": bool(
+                writer_runtime is not None
+                and getattr(writer_runtime, "ready", False)
+            ),
+            "embedding": bool(_embedding_warm),
+            "recall_health": recall_health.get("recall_healthy") is True,
             "migration_failures": migration_failures,
         }
-        base_ready = all((readiness["engine"], readiness["migrations"]))
-        fully_ready = base_ready and readiness["retrieval"]
-        runtime_state = (
-            "ready" if fully_ready else "warming" if base_ready else "not_ready"
+        readiness["retrieval"] = bool(
+            readiness["embedding"] and readiness["recall_health"]
         )
-        # v3.6.8: surface the recall-health verdict so a silently-degraded
-        # recall path (warm-but-broken embedder) is VISIBLE, never silent.
-        try:
-            from superlocalmemory.server.recall_health import get_recall_health
-            _recall_health = get_recall_health()
-        except Exception:
-            _recall_health = {"recall_healthy": None}
+        base_ready = all((
+            readiness["engine"],
+            readiness["migrations"],
+            readiness["writer"],
+        ))
+        fully_ready = base_ready and readiness["retrieval"]
+        if fully_ready:
+            runtime_state = "serving_full"
+        elif base_ready and readiness["embedding"]:
+            runtime_state = "serving_degraded"
+        elif base_ready:
+            runtime_state = "warming"
+        else:
+            runtime_state = "not_ready"
+        lifecycle_state = "ready" if base_ready else "starting"
         identity = getattr(application.state, "daemon_descriptor", None)
         from superlocalmemory.server.profile_runtime import get_profile_runtime
 
@@ -2970,14 +3199,20 @@ def _register_daemon_routes(application: FastAPI) -> None:
             "ready": fully_ready,
             # Runtime readiness is more precise than descriptor lifecycle.
             # A process can be alive and identity-valid while retrieval warms.
-            "state": runtime_state,
+            "state": lifecycle_state,
+            "runtime_state": runtime_state,
             "version": getattr(application, 'version', 'unknown'),
         }
         # 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
@@ -2993,12 +3228,12 @@ def _register_daemon_routes(application: FastAPI) -> None:
             "embedding_warm": _embedding_warm,
             # v3.6.8: True iff the semantic channel actually fired on the last
             # health probe; includes self-heal counters.
-            "recall_health": _recall_health,
+            "recall_health": recall_health,
             **(identity.public_health_fields() if identity is not None else {}),
-            # runtime_state must come AFTER the identity spread so the live
-            # readiness state wins over the descriptor's last-known lifecycle
-            # value (which can be "starting").
-            "state": runtime_state,
+            # Lifecycle state remains backward compatible for daemon
+            # discovery; channel degradation is exposed separately.
+            "state": lifecycle_state,
+            "runtime_state": runtime_state,
             "active_profile": profile_snapshot.profile_id,
             "profile_generation": profile_snapshot.generation,
         }
@@ -3163,11 +3398,11 @@ def _register_daemon_routes(application: FastAPI) -> None:
         request: Request,
         wait: bool = False,
     ):
-        """Persist through the durable canonical ingestion state machine.
+        """Journal and commit a bounded, immediately-queryable receipt.
 
-        The default path returns after the relational/FTS projection is
-        queryable.  ``wait=true`` materializes the same operation inline; the
-        background worker handles all other queryable operations.
+        ``wait`` remains accepted for compatibility, but never permits inline
+        enrichment on this path. The daemon materializer owns all model, graph,
+        vector, and post-hook work after this response.
         """
         trusted_actor_id = _require_write_actor(request)
         _update_activity()
@@ -3180,14 +3415,29 @@ def _register_daemon_routes(application: FastAPI) -> None:
         scope = req.scope or getattr(_scope_cfg, "default_scope", "personal")
         shared_with = req.shared_with
 
-        try:
-            from superlocalmemory.core.engine_ingestion import (
-                build_engine_ingestion_command,
+        # Keep the daemon compatibility route behind the exact RBAC/session
+        # boundary used by dashboard mutations. Machine authentication proves
+        # the caller may reach this daemon; WRITE permission proves the
+        # authenticated dashboard user may mutate this profile. This must run
+        # before either the trust pre-hook or the durable admission journal.
+        from superlocalmemory.access.rbac import Permission
+        from superlocalmemory.server.rbac_enforce import require_permission
+
+        require_permission(request, Permission.WRITE, profile=engine._profile_id)
+        if scope in {"shared", "global"}:
+            require_permission(request, Permission.SHARE, profile=engine._profile_id)
+        runtime = getattr(application.state, "canonical_remember_runtime", None)
+        if runtime is None:
+            raise HTTPException(
+                503,
+                detail="canonical remember writer is not ready; retry shortly",
             )
-            from superlocalmemory.core.ingestion_command import (
-                IngestionRequest,
-                IngestionState,
+
+        try:
+            from superlocalmemory.core.remember_runtime import (
+                validate_deterministic_admission,
             )
+            from superlocalmemory.storage.admission_journal import Actor, RememberRequest
 
             meta = {}
             if req.tags:
@@ -3195,8 +3445,32 @@ def _register_daemon_routes(application: FastAPI) -> None:
             extra = getattr(req, "metadata", None)
             if isinstance(extra, dict):
                 meta.update(extra)
-            command = build_engine_ingestion_command(engine)
-            ingestion_request = IngestionRequest(
+
+            store_config = getattr(engine._config, "store", None)
+            validate_deterministic_admission(
+                req.content,
+                max_verbatim_chars=getattr(
+                    store_config,
+                    "max_verbatim_chars",
+                    24_000,
+                ),
+                max_ingest_bytes=getattr(
+                    store_config,
+                    "max_ingest_bytes",
+                    1_048_576,
+                ),
+            )
+
+            # Trust policy is intentionally outside both the journal and the
+            # coordinator transaction. It can reject or audit a caller, but
+            # cannot hold SQLite's sole writer while hooks do their work.
+            engine._hooks.run_pre("store", {
+                "operation": "store",
+                "agent_id": trusted_actor_id,
+                "profile_id": engine._profile_id,
+                "content_preview": req.content[:100],
+            })
+            admission = RememberRequest(
                 content=req.content,
                 profile_id=engine._profile_id,
                 source_type="http",
@@ -3207,93 +3481,63 @@ def _register_daemon_routes(application: FastAPI) -> None:
                 trusted_actor_id=trusted_actor_id,
                 session_id=req.session_id,
             )
-            # SQLite admission is usually milliseconds, but it can wait on a
-            # concurrent migration or writer.  Keep that wait out of ASGI so
-            # dashboard navigation and recall stay responsive.
-            receipt = await asyncio.to_thread(command.submit, ingestion_request)
-            result = receipt
-            wait_budget_exhausted = False
-            if wait:
-                materialization_task = asyncio.create_task(
-                    asyncio.to_thread(command.materialize, receipt.operation_id)
-                )
-                try:
-                    result = await asyncio.wait_for(
-                        asyncio.shield(materialization_task),
-                        timeout=_REMEMBER_ENRICHMENT_WAIT_SECONDS,
-                    )
-                except TimeoutError:
-                    # The task retains the M018 lease and continues outside
-                    # this request.  Return the durable receipt honestly;
-                    # the normal materializer can also reclaim it after a
-                    # lease expiry if the request-owned worker dies.
-                    wait_budget_exhausted = True
-
-                    def _log_background_materialization(task):
-                        try:
-                            task.result()
-                        except Exception as exc:
-                            logger.warning(
-                                "bounded remember enrichment failed for %s: %s",
-                                receipt.operation_id,
-                                exc,
-                            )
-
-                    materialization_task.add_done_callback(
-                        _log_background_materialization
-                    )
-            fact_ids = list(result.fact_ids)
-            # The queryable write is a separate durable transaction.  A cold
-            # optional enrichment dependency (most often the local embedding
-            # worker) may need its bounded retry window, but must not turn an
-            # already-admitted fact into an HTTP 500.  Keep the operation's
-            # failed state truthful so the daemon materializer retries it; the
-            # response communicates that the fact is queryable, not complete.
-            enrichment_deferred = (
-                result.state is IngestionState.FAILED and bool(fact_ids)
+            actor = Actor(
+                principal_id=trusted_actor_id,
+                allowed_profiles=frozenset({engine._profile_id}),
+                allowed_scopes=frozenset({scope}),
             )
-            if result.state is IngestionState.FAILED and not enrichment_deferred:
-                raise RuntimeError(result.last_error or "materialization failed")
-            completed = result.state is IngestionState.COMPLETE
-            _emit_event(
-                "memory.stored" if completed else "memory.queued",
-                payload={
-                    "operation_id": result.operation_id,
-                    "fact_ids": fact_ids,
-                    "tags": req.tags or "",
-                    "content_preview": req.content[:120],
-                    "path": (
-                        "remember_sync"
-                        if completed
-                        else "remember_sync_deferred"
-                        if enrichment_deferred
-                        else "remember_queryable"
-                    ),
-                },
+            receipt = await asyncio.to_thread(
+                runtime.remember,
+                admission,
+                actor,
+                deadline_ms=2_000,
             )
+            payload = dict(receipt.payload)
+            fact_ids = list(payload.get("fact_ids") or [])
             return {
                 "ok": True,
                 "fact_ids": fact_ids,
                 "count": len(fact_ids),
-                "operation_id": result.operation_id,
+                "operation_id": payload["operation_id"],
                 # One-release compatibility alias. The durable operation ID is
                 # opaque and replaces the integer pending.db row identifier.
-                "pending_id": result.operation_id,
-                "status": "stored" if completed else "queryable",
-                "materialization_state": result.state.value,
-                "note": (
-                    "canonical ingestion complete"
-                    if completed
-                    else "queryable now; enrichment continues after the wait budget"
-                    if wait_budget_exhausted
-                    else "queryable now; canonical enrichment will retry"
-                    if enrichment_deferred
-                    else "queryable now; canonical enrichment pending"
-                ),
-                "wait_budget_exhausted": wait_budget_exhausted,
+                "pending_id": payload["pending_id"],
+                "status": "queryable",
+                "materialization_state": payload["materialization_state"],
+                "commit_sequence": payload.get("commit_sequence"),
+                "note": "queryable now; canonical enrichment continues in the background",
+                "wait_ignored": bool(wait),
             }
         except Exception as exc:
-            raise HTTPException(500, detail=str(exc))
+            from superlocalmemory.core.remember_admission import AdmissionRejected
+            from superlocalmemory.core.remember_runtime import CanonicalRememberUnavailable
+            from superlocalmemory.storage.admission_journal import (
+                AdmissionAuthorizationError,
+                AdmissionPayloadError,
+                IdempotencyConflict,
+            )
+
+            if isinstance(exc, CanonicalRememberUnavailable) or (
+                isinstance(exc, AdmissionRejected) and exc.retryable
+            ):
+                raise HTTPException(
+                    503,
+                    detail="canonical remember is temporarily unavailable; retry shortly",
+                ) from exc
+            if isinstance(exc, AdmissionRejected):
+                raise HTTPException(
+                    422,
+                    detail="remember admission was rejected by deterministic policy",
+                ) from exc
+            if isinstance(exc, (AdmissionAuthorizationError, PermissionError)):
+                raise HTTPException(403, detail="remember admission is not authorized") from exc
+            if isinstance(
+                exc,
+                (AdmissionPayloadError, IdempotencyConflict),
+            ):
+                raise HTTPException(422, detail=str(exc)) from exc
+            logger.exception("canonical remember admission failed")
+            raise HTTPException(500, detail="canonical remember admission failed") from exc
 
     @application.post("/observe")
     async def observe(req: ObserveRequest, request: Request):
@@ -3781,6 +4025,17 @@ def _materialize_ingestion_one_pass(
     from superlocalmemory.core.ingestion_command import IngestionState
 
     command = build_engine_ingestion_command(engine)
+    reap = getattr(command.repository, "reap_stuck_enriching", None)
+    try:
+        reaped = reap() if callable(reap) else []
+    except Exception as exc:
+        logger.warning("ingestion reaper failed; materializer pass continues: %s", exc)
+        reaped = []
+    if reaped:
+        logger.warning(
+            "Materializer terminalized %d exhausted ingestion operation(s)",
+            len(reaped),
+        )
     completed = failed = 0
     for operation in command.repository.list_materializable(
         limit=limit,
@@ -4007,7 +4262,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