superlocalmemory 3.6.2 → 3.6.4

package/src/superlocalmemory/core/store_pipeline.py

@@ -102,6 +102,37 @@ def enrich_fact(
     )
 
 
+# ---------------------------------------------------------------------------
+# Vector dual-write helper (P1-2 / embeddings-vector-01)
+# ---------------------------------------------------------------------------
+
+def _upsert_fact_vectors(fact, profile_id, ann_index, vector_store, embedder=None):
+    """Dual-write a fact's embedding to the ANN index + sqlite-vec store.
+
+    Embeds on-demand when the fact has no embedding (e.g. consolidated
+    summary facts created without one), so UPDATE/SUPERSEDE and consolidated
+    facts remain visible to the semantic channel instead of having a row in
+    ``atomic_facts`` but none in the vector store.
+    """
+    if not getattr(fact, "embedding", None) and embedder is not None and fact.content:
+        try:
+            fact.embedding = embedder.embed(fact.content)
+        except Exception as _emb_exc:  # pragma: no cover - defensive
+            logger.debug("on-demand embed failed for %s: %s", fact.fact_id, _emb_exc)
+            return
+    if not getattr(fact, "embedding", None):
+        return
+    if ann_index:
+        ann_index.add(fact.fact_id, fact.embedding)
+    # V3.2: VectorStore upsert (sqlite-vec) -- dual-write (Rule 12)
+    if vector_store and getattr(vector_store, "available", False):
+        vector_store.upsert(
+            fact_id=fact.fact_id,
+            profile_id=profile_id,
+            embedding=fact.embedding,
+        )
+
+
 # ---------------------------------------------------------------------------
 # run_store  (was MemoryEngine.store)
 # ---------------------------------------------------------------------------
@@ -175,10 +206,20 @@ def run_store(
     )
     db.store_memory(record)
 
-    facts = fact_extractor.extract_facts(
-        turns=[content], session_id=session_id,
-        session_date=parsed_date, speaker_a=speaker,
-    )
+    try:
+        facts = fact_extractor.extract_facts(
+            turns=[content], session_id=session_id,
+            session_date=parsed_date, speaker_a=speaker,
+        )
+    except Exception as _extract_exc:
+        # P0-1 (remember-write-04): an extractor EXCEPTION (transient LLM/embed
+        # backend error) must NOT orphan the already-committed memory. The None
+        # guard below only handled a None *return*, not a raise. Treat a raise
+        # as "no facts" so the verbatim/raw fallback persists the content.
+        logger.warning(
+            "extract_facts() raised — falling back to raw fact: %s", _extract_exc,
+        )
+        facts = None
 
     # v3.4.38: Defensive None guard. extract_facts() returns None on transient
     # failures (embedding worker timeout, LLM call fail). Without this guard,
@@ -257,58 +298,77 @@ def run_store(
         )
 
         if consolidator:
-            action = consolidator.consolidate(fact, profile_id)
-            if action.action_type.value == "noop":
-                continue
-
-            # Opinion confidence tracking: reinforce or decay
-            if fact.fact_type == FactType.OPINION and action.action_type.value == "update":
-                try:
-                    existing = db.get_fact(action.new_fact_id)
-                    if existing and existing.fact_type == FactType.OPINION:
-                        new_conf = min(1.0, existing.confidence + 0.1)
-                        db.update_fact(action.new_fact_id, {"confidence": new_conf})
-                except Exception:
-                    pass
-            elif fact.fact_type == FactType.OPINION and action.action_type.value == "supersede":
-                try:
-                    old_id = getattr(action, "old_fact_id", None)
-                    if old_id:
-                        old_fact = db.get_fact(old_id)
-                        if old_fact:
-                            new_conf = max(0.0, old_fact.confidence - 0.2)
-                            db.update_fact(old_id, {"confidence": new_conf})
-                except Exception:
-                    pass
-
-            if action.action_type.value in ("update", "supersede"):
-                updated_fact = db.get_fact(action.new_fact_id)
-                if updated_fact:
-                    if graph_builder:
-                        graph_builder.build_edges(updated_fact, profile_id)
-                    if observation_builder:
-                        for eid in updated_fact.canonical_entities:
-                            observation_builder.update_profile(
-                                eid, updated_fact, profile_id,
-                            )
-                stored_ids.append(action.new_fact_id)
-                continue
-            # ADD case: consolidator already stored the fact (F8 fix)
-            # Fall through to post-processing below
+            try:
+                action = consolidator.consolidate(fact, profile_id)
+            except Exception as _consolidate_exc:
+                # P0-1 (remember-write-03): a consolidate failure (e.g. LLM
+                # timeout) must NOT orphan the already-committed memory. Fall
+                # back to storing the raw enriched fact so the content stays
+                # retrievable across all channels.
+                logger.warning(
+                    "consolidate() failed for fact %s — storing raw fact as "
+                    "fallback: %s", fact.fact_id, _consolidate_exc,
+                )
+                action = None
+
+            if action is not None:
+                if action.action_type.value == "noop":
+                    continue
+
+                # Opinion confidence tracking: reinforce or decay
+                if fact.fact_type == FactType.OPINION and action.action_type.value == "update":
+                    try:
+                        existing = db.get_fact(action.new_fact_id)
+                        if existing and existing.fact_type == FactType.OPINION:
+                            new_conf = min(1.0, existing.confidence + 0.1)
+                            db.update_fact(action.new_fact_id, {"confidence": new_conf})
+                    except Exception:
+                        pass
+                elif fact.fact_type == FactType.OPINION and action.action_type.value == "supersede":
+                    try:
+                        old_id = getattr(action, "old_fact_id", None)
+                        if old_id:
+                            old_fact = db.get_fact(old_id)
+                            if old_fact:
+                                new_conf = max(0.0, old_fact.confidence - 0.2)
+                                db.update_fact(old_id, {"confidence": new_conf})
+                    except Exception:
+                        pass
+
+                if action.action_type.value in ("update", "supersede"):
+                    updated_fact = db.get_fact(action.new_fact_id)
+                    if updated_fact:
+                        # P1-2 (embeddings-vector-01): the merged/superseding
+                        # fact must reach the vector store (embed on-demand if
+                        # it has none) — otherwise it is invisible to the
+                        # semantic channel despite living in atomic_facts.
+                        _upsert_fact_vectors(
+                            updated_fact, profile_id, ann_index, vector_store, embedder,
+                        )
+                        if graph_builder:
+                            graph_builder.build_edges(updated_fact, profile_id)
+                        if observation_builder:
+                            for eid in updated_fact.canonical_entities:
+                                observation_builder.update_profile(
+                                    eid, updated_fact, profile_id,
+                                )
+                    stored_ids.append(action.new_fact_id)
+                    continue
+                # ADD case: consolidator already stored the fact (F8 fix)
+                # Fall through to post-processing below
+            else:
+                # Consolidate failed → store the raw fact ourselves so the
+                # memory is never left without a retrievable fact, then fall
+                # through to post-processing (embeddings, graph, context).
+                db.store_fact(fact)
         else:
             db.store_fact(fact)
 
         stored_ids.append(fact.fact_id)
 
-        if fact.embedding and ann_index:
-            ann_index.add(fact.fact_id, fact.embedding)
-        # V3.2: VectorStore upsert (sqlite-vec) -- dual-write (Rule 12)
-        if fact.embedding and vector_store and vector_store.available:
-            vector_store.upsert(
-                fact_id=fact.fact_id,
-                profile_id=profile_id,
-                embedding=fact.embedding,
-            )
+        # Dual-write embedding to ANN index + vector store (embed on-demand if
+        # a consolidated ADD fact arrived without one). See _upsert_fact_vectors.
+        _upsert_fact_vectors(fact, profile_id, ann_index, vector_store, embedder)
         # Phase 2: Generate contextual description (after consolidator, before graph_builder)
         if context_generator:
             try:
@@ -489,6 +549,15 @@ def run_store_fact_direct(
     and graph edges are all populated — even for auxiliary data.
     Creates a parent memory record to satisfy FK constraint.
     """
+    # remember-write-02: gate low-quality content (empty, bare category tags,
+    # placeholder/template leakage) at the WRITE boundary, matching run_store's
+    # gate. Previously this direct path had no filter, so junk entered the KB
+    # and polluted evidence/stats/embeddings (the read-side filter only hid it).
+    from superlocalmemory.core.injection import is_low_quality
+    if is_low_quality(fact.content):
+        logger.debug("run_store_fact_direct: skipping low-quality content")
+        return fact.fact_id
+
     # Create parent memory record (FK: atomic_facts.memory_id → memories.memory_id)
     if not fact.memory_id:
         record = MemoryRecord(

package/src/superlocalmemory/mcp/_stdin_guard.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Pure decision logic for the MCP stdin-EOF self-termination monitor.
+
+Isolated here (no imports, no side effects) so the kqueue ``EV_EOF``
+handling contract is unit-testable without importing the FastMCP server
+module, which starts daemon threads and auto-starts the SLM daemon at
+import time.
+
+Background (v3.6.4 fix)
+-----------------------
+The stdin-EOF monitor (``superlocalmemory.mcp.server._stdin_eof_monitor``)
+exists to reap orphaned ``slm mcp`` processes when an IDE/agent abandons the
+stdio pipe without quitting. It registers ``EVFILT_READ | EV_EOF`` on stdin
+and terminates the process when the write-end closes.
+
+On macOS, ``EVFILT_READ`` reports ``EV_EOF`` *together with* still-readable
+bytes (``ev.data > 0``) when the write-end is closed while a final request
+is still buffered in the pipe. The original monitor exited on the EOF flag
+alone — dropping that buffered request and tearing down a session that
+still had a pending in-flight call. Under strict MCP hosts whose transport
+half-closes stdin around reconnect/teardown, this surfaced as the server
+self-terminating mid-request, which the host then logged as a keepalive
+failure and respawned (observed against the Hermes agent).
+
+The guard defers termination until the buffer is genuinely drained
+(``ev.data <= 0``), letting the FastMCP reader consume the last request
+first. Genuine disconnects (EOF with an empty buffer) still terminate
+immediately — behaviour identical to before for the common case.
+"""
+
+from __future__ import annotations
+
+__all__ = ["eof_action"]
+
+
+def eof_action(flags: int, data: int, eof_flag: int) -> str:
+    """Decide how the stdin-EOF monitor should react to one kqueue event.
+
+    Args:
+        flags: ``kevent.flags`` bitmask returned by ``kqueue.control``.
+        data: ``kevent.data`` — for ``EVFILT_READ`` this is the number of
+            bytes still readable on the descriptor.
+        eof_flag: the platform ``select.KQ_EV_EOF`` constant (injected so
+            this function stays import-free and trivially testable).
+
+    Returns:
+        - ``"exit"``   — genuine end-of-stream: write-end closed and the
+          buffer is drained (``data <= 0``). Safe to self-terminate.
+        - ``"drain"``  — write-end closed but unread bytes remain
+          (``data > 0``). Must NOT terminate yet; let the reader consume
+          the buffered request first, otherwise it is silently dropped.
+        - ``"ignore"`` — no EOF on this event (ordinary readability or a
+          spurious wake); nothing to do.
+    """
+    if not (flags & eof_flag):
+        return "ignore"
+    return "drain" if data > 0 else "exit"

package/src/superlocalmemory/mcp/server.py

@@ -288,11 +288,26 @@ _watchdog_thread.start()
 # closes WITHOUT consuming any bytes, so it cannot race with FastMCP's asyncio
 # stdin reader. On Linux (no kqueue), the watchdog alone provides coverage.
 def _stdin_eof_monitor() -> None:
-    """Exit when the IDE closes our stdin pipe (kqueue — macOS only)."""
-    import select as _sel, os as _os_eof
+    """Exit when the IDE closes our stdin pipe (kqueue — macOS only).
+
+    V3.6.4: kqueue ``EVFILT_READ`` reports ``EV_EOF`` *together with*
+    still-readable bytes (``ev.data > 0``) when the write-end closes while a
+    final request is buffered. Exiting on the EOF flag alone (pre-3.6.4)
+    dropped that in-flight request and self-terminated a session that still
+    had work to deliver — strict MCP hosts (e.g. the Hermes agent) then
+    logged a keepalive failure and respawned the process. We now defer
+    termination until the buffer is genuinely drained (see ``_stdin_guard``).
+    """
+    import select as _sel, os as _os_eof, time as _time
+    from superlocalmemory.mcp._stdin_guard import eof_action
     _mlog = logging.getLogger(__name__ + ".stdin_monitor")
     if not hasattr(_sel, "kqueue"):
         return  # Linux / non-macOS: watchdog covers process death
+    # Bounded grace for the FastMCP reader to drain a buffered final request
+    # before we tear down. ~2 s ceiling (40 × 50 ms): a genuine EOF means the
+    # session is ending regardless, so we never wait indefinitely.
+    _DRAIN_POLL_S = 0.05
+    _DRAIN_MAX_POLLS = 40
     try:
         fd = sys.stdin.fileno()
         kq = _sel.kqueue()
@@ -301,9 +316,23 @@ def _stdin_eof_monitor() -> None:
         while True:
             evs = kq.control(None, 4, 30.0)  # 30 s poll — low cost
             for ev in evs:
-                if ev.flags & _sel.KQ_EV_EOF:
-                    _mlog.info("stdin write-end closed (kqueue EOF), self-terminating")
-                    _os_eof._exit(0)
+                action = eof_action(ev.flags, ev.data, _sel.KQ_EV_EOF)
+                if action == "ignore":
+                    continue
+                if action == "drain":
+                    # Write-end closed but unread bytes remain. Let the
+                    # FastMCP reader consume the final request(s); poll until
+                    # drained or the grace ceiling elapses.
+                    for _ in range(_DRAIN_MAX_POLLS):
+                        _time.sleep(_DRAIN_POLL_S)
+                        recheck = kq.control(None, 4, 0)  # non-blocking
+                        if not recheck:
+                            break
+                        ev = recheck[0]
+                        if eof_action(ev.flags, ev.data, _sel.KQ_EV_EOF) != "drain":
+                            break
+                _mlog.info("stdin write-end closed (kqueue EOF, drained), self-terminating")
+                _os_eof._exit(0)
     except Exception as exc:
         _mlog.debug("stdin EOF monitor error: %s — watchdog will cover", exc)
 

package/src/superlocalmemory/optimize/adapters/wrap.py

@@ -21,10 +21,19 @@ _STATIC_MECHANISMS = {"settings-file", "config-file", "print-only"}
 
 
 def _proxy_configured() -> bool:
-    """Return True if proxy_enabled=True in optimize.json (no liveness check)."""
+    """Return True if proxy_enabled=True in optimize.json (no liveness check).
+
+    Reads from the module-level _store if it has been set (daemon process or
+    tests that call _set_config_store). Falls back to a fresh ConfigStore read
+    from disk when _store is None — which is always the case in CLI subprocess
+    context because _set_config_store() is only called by the daemon on startup.
+    """
     try:
-        from superlocalmemory.optimize.config import get_optimize_config
-        return get_optimize_config().proxy_enabled
+        from superlocalmemory.optimize.config import _store
+        if _store is not None:
+            return _store.get().proxy_enabled
+        from superlocalmemory.optimize.config.store import ConfigStore
+        return ConfigStore().get().proxy_enabled
     except Exception:
         return False
 

package/src/superlocalmemory/optimize/cache/manager.py

@@ -153,9 +153,42 @@ class CacheManager:
     # ---- INTERFACE-CONTRACT §4 public methods ----
 
     def build_key(self, req: Any, tenant_id: str) -> str | None:
-        """Build a deterministic cache key for req + tenant_id."""
-        if isinstance(req, dict):
-            model_id = req.get("model", "")
+        """Build a deterministic cache key for req + tenant_id.
+
+        BUG-FIX (v3.6.3): Two bugs repaired here:
+        1. tenant_id="default" failed KeyBuilder's 64-char hex SHA-256 validation,
+           silently raising ValueError caught by fail-open wrappers → cache never
+           stored or retrieved anything via the proxy path. Fix: normalize any
+           non-hex tenant_id to its SHA-256 digest before passing to KeyBuilder.
+        2. ProxyRequest objects have a `body` dict, not model_id/messages/system
+           attributes. The old `getattr(req, "model_id", "")` path silently
+           returned empty strings → all proxy requests got the same (invalid) key.
+           Fix: detect ProxyRequest and extract fields from .body.
+        """
+        import hashlib as _hashlib
+        import json as _json
+        import re as _re
+        _HEX64 = _re.compile(r"[0-9a-f]{64}")
+        # Normalize tenant_id: KeyBuilder requires a 64-char lowercase hex SHA-256.
+        if not _HEX64.fullmatch(tenant_id or ""):
+            tenant_id = _hashlib.sha256(tenant_id.encode()).hexdigest()
+
+        if isinstance(req, ProxyRequest):
+            # Extract semantic fields from the parsed JSON body.
+            body = req.body or {}
+            model_id = body.get("model", "") or ""
+            messages = body.get("messages", []) or []
+            system_raw = body.get("system", "") or ""
+            # Anthropic allows system as a list of content blocks — normalise to str.
+            if isinstance(system_raw, list):
+                system = _json.dumps(system_raw, sort_keys=True, separators=(",", ":"))
+            else:
+                system = str(system_raw)
+            # params: everything except fields extracted above and stream flag.
+            _SKIP = frozenset({"model", "messages", "system", "stream"})
+            params = {k: v for k, v in body.items() if k not in _SKIP}
+        elif isinstance(req, dict):
+            model_id = req.get("model", "") or ""
             messages = req.get("messages", []) or []
             params = req.get("params", {}) or {}
             system = req.get("system", "") or ""
@@ -174,9 +207,18 @@ class CacheManager:
         )
 
     def get(self, req: Any, tenant_id: str) -> "CachedResponse | None":
-        """CacheHook.check() entry point."""
+        """CacheHook.check() entry point.
+
+        BUG-FIX (v3.6.3): Previously returned None on cache miss, which caused
+        _safe_cache_check to return CachedResponse(cache_key="").  The empty
+        cache_key is falsy, so the store condition in handle_messages
+        (``cache_result.cache_key``) was always False → cache was NEVER
+        populated.  Fix: return a miss CachedResponse that carries the computed
+        key so the store path can proceed.
+        """
         key = self.build_key(req, tenant_id)
         if key is None:
+            # Uncacheable (non-zero temperature, etc.) — signal with None.
             return None
         row = self._exact.get(key, tenant_id)
         if row is not None:
@@ -188,7 +230,8 @@ class CacheManager:
                 ttl_seconds=0,
             )
         self._metrics.exact_misses += 1
-        return None
+        # Return miss WITH the key so callers can use it for cache storage.
+        return CachedResponse(hit=False, data=None, cache_key=key, ttl_seconds=0)
 
     def set(self, req: Any, resp: Any, tenant_id: str) -> None:
         """CacheHook.store() entry point."""
@@ -196,8 +239,10 @@ class CacheManager:
         key = self.build_key(req, tenant_id)
         if key is None:
             return
-        if isinstance(req, dict):
-            model_id = req.get("model", "")
+        if isinstance(req, ProxyRequest):
+            model_id = (req.body or {}).get("model", "") or ""
+        elif isinstance(req, dict):
+            model_id = req.get("model", "") or ""
         else:
             model_id = getattr(req, "model_id", "") or ""
         tags = [
@@ -216,9 +261,18 @@ class CacheManager:
     # ---- CacheHook protocol implementation (INTERFACE-CONTRACT §3) ----
 
     def check(self, req: ProxyRequest) -> "CachedResponse | None":
-        """CacheHook.check() — look up by ProxyRequest; fail-open on error."""
+        """CacheHook.check() — look up by ProxyRequest; fail-open on error.
+
+        BUG-FIX (v3.6.3): on_miss() was never called from the proxy path,
+        so MetricsCollector.misses stayed at 0 and the dashboard always showed
+        0 misses.  Fixed by calling on_miss() here whenever get() returns a
+        cache-miss result.
+        """
         try:
-            return self.get(req, tenant_id="default")
+            result = self.get(req, tenant_id="default")
+            if result is not None and not result.hit:
+                MetricsCollector.get_instance().on_miss()
+            return result
         except Exception as exc:
             logger.warning("CacheManager.check raised (fail-open): %s", exc)
             return None

package/src/superlocalmemory/optimize/compress/router.py

@@ -71,10 +71,6 @@ class CompressRouter:
 
             if not cfg.compress_enabled:
                 return req
-            if req.stream:
-                return req
-            if req.has_tools:
-                return req  # §6.5 safety rule
 
             body = dict(req.body)
             messages = body.get("messages", [])
@@ -139,8 +135,8 @@ class CompressRouter:
         try:
             saved = max(0, before_tokens - after_tokens)
             if self._metrics_counters is not None:
-                # M-02: Call proper method instead of accessing private attribute
-                self._metrics_counters.on_compress(saved, lossy)
+                # M-02: pass before/after directly (bytes_original, bytes_after contract)
+                self._metrics_counters.on_compress(before_tokens, after_tokens)
             logger.debug("on_compress: saved=%d tokens lossy=%s", saved, lossy)
         except Exception as exc:
             logger.debug("on_compress metrics update failed (non-fatal): %s", exc)
@@ -169,9 +165,11 @@ class CompressRouter:
         for idx, msg in enumerate(messages):
             role = msg.get("role", "")
             is_tool_msg = (
-                role == "tool"
-                or role == "user"
-                or _msg_has_tool_result(msg)
+                role == "tool"  # OpenAI tool result messages (plain text, skip entirely)
+                # Anthropic tool_result blocks are NOT skipped — _compress_content_block
+                # handles type=="tool_result" blocks by compressing their text content
+                # while preserving the block structure. This is where the bulk of
+                # Claude Code output lives (bash results, file contents, JSON data).
             )
             if idx in protect_indices or is_tool_msg:
                 new_messages.append(msg)