superlocalmemory 3.8.0 → 3.8.1

package/src/superlocalmemory/mcp/tools_core.py

@@ -84,8 +84,9 @@ def _record_recall_hits(
             enqueue_shown_flip,
         )
 
-        engine = get_engine()
-        pid = profile_id or engine.profile_id
+        pid = profile_id
+        if not pid:
+            pid = get_engine().profile_id
         slm_dir = canonical_data_root()
 
         shown_ids = [r.get("fact_id", "") for r in results[:10]
@@ -121,7 +122,7 @@ def _record_recall_hits(
 def register_core_tools(server, get_engine: Callable) -> None:
     """Register the 13 core MCP tools on *server*."""
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def remember(
         content: str, tags: str = "", project: str = "",
         importance: int = 5, session_id: str = "",

package/src/superlocalmemory/mcp/tools_learning.py

@@ -143,7 +143,7 @@ def register_learning_tools(server, get_engine: Callable) -> None:
             logger.debug("get_assertions failed: %s", exc)
             return {"assertions": [], "count": 0, "error": str(exc)}
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def reinforce_assertion(assertion_id: str) -> dict:
         """Reinforce a behavioral assertion (increase confidence).
 
@@ -171,7 +171,7 @@ def register_learning_tools(server, get_engine: Callable) -> None:
         except Exception as exc:
             return {"success": False, "error": str(exc)}
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def contradict_assertion(assertion_id: str) -> dict:
         """Contradict a behavioral assertion (decrease confidence).
 

package/src/superlocalmemory/retrieval/engine.py

@@ -679,32 +679,47 @@ class RetrievalEngine:
         fused: list,
         ch_results: dict[str, list[tuple[str, float]]],
         effective_limit: int,
-        min_per_channel: int = 2,
     ) -> list:
-        """Ensure structure channels (entity_graph) get representation.
-
-        V3.4.11: entity_graph finds valid results but RRF scores them low
-        because they don't overlap with semantic/bm25 results. This interleaves
-        top entity_graph facts into positions 3-4 of the final output instead
-        of appending at the end where they'd never be seen.
+        """Keep strong lexical and structure evidence visible in the result cap.
+
+        A semantic channel with a larger weight can fill a small result limit
+        even when BM25 has an exact, high-signal hit. That broke the
+        ``queryable now`` ingestion contract: a freshly inserted FTS row could
+        exist durably but remain invisible to immediate recall. Reserve one
+        capped slot for a strong BM25 hit and two for a structure channel when
+        such candidates exist, without returning more than ``effective_limit``.
         """
-        structure_channels = ["entity_graph"]
+        channel_minimums = (
+            ("bm25", 1, 0.0),
+            ("entity_graph", 2, 0.0),
+        )
         top_ids = {fr.fact_id for fr in top}
 
         promoted = []
-        for ch_name in structure_channels:
+        for ch_name, minimum, score_floor in channel_minimums:
             ch_items = ch_results.get(ch_name, [])
             if not ch_items:
                 continue
 
-            present = sum(1 for fid, _ in ch_items if fid in top_ids)
-            if present >= min_per_channel:
+            eligible_ids = {
+                fid
+                for fid, score in ch_items
+                if (
+                    float(score) > score_floor
+                    if ch_name == "bm25"
+                    else float(score) >= score_floor
+                )
+            }
+            if not eligible_ids:
+                continue
+
+            present = sum(1 for fid in eligible_ids if fid in top_ids)
+            if present >= minimum:
                 continue
 
-            needed = min_per_channel - present
-            ch_fids = {fid for fid, _ in ch_items}
+            needed = minimum - present
             for fr in fused:
-                if fr.fact_id in ch_fids and fr.fact_id not in top_ids:
+                if fr.fact_id in eligible_ids and fr.fact_id not in top_ids:
                     promoted.append(fr)
                     top_ids.add(fr.fact_id)
                     needed -= 1
@@ -714,10 +729,15 @@ class RetrievalEngine:
         if not promoted:
             return top
 
-        # Append as safety net — with proper RRF weights (strategy.py),
-        # entity_graph facts should already rank naturally in the top-k.
-        # This only fires when they're still missing despite weight boost.
-        return list(top) + promoted
+        selected = promoted[:effective_limit]
+        result = list(top[:effective_limit])
+        free_slots = max(0, effective_limit - len(result))
+        result.extend(selected[:free_slots])
+        remaining = selected[free_slots:]
+        if remaining:
+            keep = max(0, effective_limit - len(remaining))
+            result = result[:keep] + remaining
+        return result[:effective_limit]
 
     # -- Channel execution --------------------------------------------------
 
@@ -853,14 +873,26 @@ class RetrievalEngine:
                 q_emb, profile_id, self._config.bm25_top_k,
             )
 
-        # Collect results as channels complete.
+        # Each local channel gets a strict latency budget.  A slow graph walk
+        # must not make an interactive recall wait 30 seconds; completed
+        # channels still participate in fusion and the timeout is observable.
+        channel_timeout_seconds = 1.0
+        # One shared deadline keeps parallel dispatch genuinely bounded.  A
+        # per-future timeout here would serialise the wait and turn five slow
+        # channels into five seconds of UI latency.
+        done, pending = concurrent.futures.wait(
+            futures.values(), timeout=channel_timeout_seconds,
+        )
         for name, fut in futures.items():
+            if fut in pending:
+                logger.warning("Channel %s exceeded %.1fs latency budget", name, channel_timeout_seconds)
+                continue
             try:
-                ch_name, result = fut.result(timeout=30)
+                ch_name, result = fut.result()
                 if result:
                     out[ch_name] = result
             except Exception as exc:
-                logger.warning("Channel %s timed out or failed: %s", name, exc)
+                logger.warning("Channel %s failed: %s", name, exc)
 
         # Apply registered post-retrieval filters (forgetting filter, etc.)
         if hasattr(self, '_registry') and self._registry._filters:

package/src/superlocalmemory/retrieval/reranker.py

@@ -25,9 +25,8 @@ import sys
 import threading
 import time
 import weakref
-from typing import Any
-
 from pathlib import Path
+from typing import Any
 
 from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.storage.models import AtomicFact
@@ -57,9 +56,9 @@ _live_rerankers: set[weakref.ref] = set()
 
 logger = logging.getLogger(__name__)
 
-_IDLE_TIMEOUT_SECONDS = 300  # V3.4.37: 5 min (was 30) — balance cold-start vs RAM.
+_IDLE_TIMEOUT_SECONDS = 1800  # V3.8.1: keep interactive sessions warm.
 # V3.3.12: Configurable via SLM_RERANKER_IDLE_TIMEOUT env var.
-# V3.4.19: Bumped from 120 → 1800 in lock-step with the embedding worker.
+# Low-RAM installations can retain aggressive recycling through the override.
 # Set ``SLM_RERANKER_IDLE_TIMEOUT=120`` + ``slm restart`` to revert.
 _IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_RERANKER_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
 _SUBPROCESS_RESPONSE_TIMEOUT = 15  # v3.4.52: 15s (was 180s). Long timeout blocked the

package/src/superlocalmemory/server/config_file.py

@@ -0,0 +1,90 @@
+"""Process-safe, durable read/modify/write access to ``config.json``."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Iterator
+
+_PROCESS_LOCK = threading.RLock()
+
+
+@contextmanager
+def _file_lock(path: Path) -> Iterator[None]:
+    """Serialize config access across daemon, CLI, and worker processes."""
+    lock_path = path.with_name(f".{path.name}.lock")
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with _PROCESS_LOCK, lock_path.open("a+b") as handle:
+        if os.name == "nt":
+            import msvcrt
+
+            handle.seek(0)
+            handle.write(b"\0")
+            handle.flush()
+            handle.seek(0)
+            msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            if os.name == "nt":
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def _read_unlocked(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError("config root must be a JSON object")
+    return value
+
+
+def read_config(path: Path) -> dict:
+    """Return one coherent config snapshot under the interprocess lock."""
+    with _file_lock(path):
+        return _read_unlocked(path)
+
+
+def update_config(path: Path, update: Callable[[dict], None]) -> dict:
+    """Atomically update and durably replace a config JSON object."""
+    with _file_lock(path):
+        data = _read_unlocked(path)
+        update(data)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        descriptor, temp_name = tempfile.mkstemp(
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            dir=path.parent,
+        )
+        temp_path = Path(temp_name)
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+                json.dump(data, stream, indent=2)
+                stream.write("\n")
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.chmod(temp_path, 0o600)
+            os.replace(temp_path, path)
+            if hasattr(os, "O_DIRECTORY"):
+                directory_fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY)
+                try:
+                    os.fsync(directory_fd)
+                finally:
+                    os.close(directory_fd)
+        finally:
+            temp_path.unlink(missing_ok=True)
+        return data
+
+
+__all__ = ("read_config", "update_config")

package/src/superlocalmemory/server/origin.py

@@ -0,0 +1,50 @@
+"""Exact browser-origin validation for the local dashboard."""
+
+from __future__ import annotations
+
+from urllib.parse import urlsplit
+
+
+_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+
+
+def origin_is_loopback(origin: str) -> bool:
+    """Return whether an Origin is absent or an exact HTTP(S) loopback URL."""
+    if not origin:
+        return True
+    try:
+        parsed = urlsplit(origin)
+        # Accessing port validates malformed/non-numeric port values.
+        _ = parsed.port
+    except (TypeError, ValueError):
+        return False
+    return (
+        parsed.scheme in {"http", "https"}
+        and parsed.hostname is not None
+        and parsed.hostname.lower() in _LOOPBACK_HOSTS
+        and parsed.username is None
+        and parsed.password is None
+        and parsed.path in {"", "/"}
+        and not parsed.query
+        and not parsed.fragment
+    )
+
+
+def origin_is_daemon(origin: str, *, port: int) -> bool:
+    """Return whether ``origin`` is one of this daemon's loopback aliases.
+
+    A loopback host alone is not a browser trust boundary: another local web
+    server can run on a different port.  Credentialless dashboard writes are
+    therefore limited to the port owned by this daemon.  Authenticated local
+    integrations are handled separately by the write-identity boundary.
+    """
+    if not origin_is_loopback(origin):
+        return False
+    try:
+        parsed = urlsplit(origin)
+        return parsed.port == port
+    except (TypeError, ValueError):
+        return False
+
+
+__all__ = ("origin_is_daemon", "origin_is_loopback")