superlocalmemory 3.7.0__tar.gz → 3.7.2__tar.gz

{superlocalmemory-3.7.0/src/superlocalmemory.egg-info → superlocalmemory-3.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.7.0
+Version: 3.7.2
 Summary: Local-first agent memory with auditable hybrid retrieval
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License-Expression: AGPL-3.0-or-later
@@ -104,10 +104,10 @@ Dynamic: license-file
   <img src="https://superlocalmemory.com/assets/logo-mark.png" alt="SuperLocalMemory" width="200"/>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.7</h1>
+<h1 align="center">SuperLocalMemory V3.7.2</h1>
 <p align="center"><strong>Cache. Compress. Remember. Three surfaces — proxy, MCP tools, or skill. Every setup covered.</strong><br/>
 <em>Local-first agent memory with explicit operating modes, auditable retrieval, and optional Optimize tools.</em></p>
-<p align="center"><code>v3.7.0</code> — <strong>Release package; registry publication gate pending.</strong><br/>
+<p align="center"><code>v3.7.2</code> — <strong>Reliability release: durable local writes, cross-platform installation, and bounded enrichment recovery.</strong><br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/README.md

@@ -2,10 +2,10 @@
   <img src="https://superlocalmemory.com/assets/logo-mark.png" alt="SuperLocalMemory" width="200"/>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.7</h1>
+<h1 align="center">SuperLocalMemory V3.7.2</h1>
 <p align="center"><strong>Cache. Compress. Remember. Three surfaces — proxy, MCP tools, or skill. Every setup covered.</strong><br/>
 <em>Local-first agent memory with explicit operating modes, auditable retrieval, and optional Optimize tools.</em></p>
-<p align="center"><code>v3.7.0</code> — <strong>Release package; registry publication gate pending.</strong><br/>
+<p align="center"><code>v3.7.2</code> — <strong>Reliability release: durable local writes, cross-platform installation, and bounded enrichment recovery.</strong><br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.7.0"
+version = "3.7.2"
 description = "Local-first agent memory with auditable hybrid retrieval"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/__init__.py

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

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/cli/_lazy_init.py

@@ -4,7 +4,7 @@
 
 """WP-07 — Lazy first-run initialisation (pip cross-install).
 
-stdlib-only — zero heavy imports, STDOUT-SILENT.
+Lightweight import only — zero heavy imports, STDOUT-SILENT.
 
 Public API
 ----------
@@ -25,6 +25,8 @@ import json
 import os
 from pathlib import Path
 
+from superlocalmemory import __version__ as _RUNTIME_VERSION
+
 
 # ---------------------------------------------------------------------------
 # Public: home resolution
@@ -55,7 +57,7 @@ def slm_home() -> Path:
 # Only mode + base_dir; everything else uses SLMConfig defaults.
 _MINIMAL_CONFIG: dict = {
     "mode": "a",
-    "version": "3.6.14",
+    "version": _RUNTIME_VERSION,
 }
 
 

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/core/embedding_worker.py

@@ -70,7 +70,13 @@ def _load_embedding_model(name: str) -> tuple:
 
     Returns (model, backend_name) or (None, "").
     """
-    from sentence_transformers import SentenceTransformer
+    try:
+        from sentence_transformers import SentenceTransformer
+    except Exception:
+        # Dependency/version errors must stay inside the JSON-lines protocol.
+        # Letting this import escape kills the worker before it can explain the
+        # failure, which the parent previously mislabeled as a long timeout.
+        return None, ""
 
     for backend in _embedding_backend_order():
         try:

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/core/embeddings.py

@@ -295,6 +295,8 @@ class EmbeddingService:
         never hangs indefinitely on cold model loads or network issues.
         """
         with self._lock:
+            if not self._available:
+                return None
             # Worker recycling: restart after N requests to prevent
             # C++ allocator fragmentation over long-running sessions.
             if self._request_count >= _WORKER_RECYCLE_AFTER and self._worker_proc is not None:
@@ -339,6 +341,12 @@ class EmbeddingService:
                 resp = json.loads(resp_line)
                 if not resp.get("ok"):
                     logger.warning("Worker error: %s", resp.get("error"))
+                    # A well-formed worker error is a terminal local
+                    # dependency/model failure, not a transient pipe race.
+                    # Disable this service and terminate the child so every
+                    # recall does not respawn a heavyweight failing process.
+                    self._available = False
+                    self._kill_worker()
                     return None
                 self._reset_idle_timer()
                 self._request_count += 1

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/core/engine.py

@@ -24,6 +24,7 @@ from typing import Any
 from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT, SLMConfig
 from superlocalmemory.core.engine_capabilities import Capabilities, CapabilityError
 from superlocalmemory.core.modes import get_capabilities
+from superlocalmemory.learning.outcome_queue import RecallEvent, enqueue_recall
 from superlocalmemory.storage.models import (
     AtomicFact, MemoryRecord, Mode, RecallResponse,
 )
@@ -664,9 +665,6 @@ class MemoryEngine:
         # recall correctness (LLD-02 §4.9, LLD-08 §4.1).
         if session_id:
             try:
-                from superlocalmemory.learning.outcome_queue import (
-                    RecallEvent, enqueue_recall,
-                )
                 fact_ids = tuple(
                     getattr(r.fact, "fact_id", "") or ""
                     for r in getattr(response, "results", [])

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/core/engine_wiring.py

@@ -22,6 +22,30 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _log_reranker_warmup_status(reranker: Any) -> None:
+    """Record non-blocking reranker warmup state without alarming first-run users."""
+    ready = reranker.warmup_sync(timeout=180)
+    if ready:
+        logger.info("Cross-encoder reranker warm and ready")
+        return
+    try:
+        from superlocalmemory.retrieval.reranker import _is_reranker_worker_alive
+
+        if _is_reranker_worker_alive():
+            logger.info(
+                "Cross-encoder reranker worker held by another process "
+                "(machine-wide singleton — usually the unified daemon); "
+                "this process will route reranking through that worker"
+            )
+            return
+    except Exception:
+        pass
+    logger.info(
+        "Cross-encoder reranker did not become ready during background warmup; "
+        "recalls use fallback scoring. Run 'slm doctor' for diagnostics."
+    )
+
+
 # ---------------------------------------------------------------------------
 # init_embedder  (was MemoryEngine._init_embedder + helpers)
 # ---------------------------------------------------------------------------
@@ -364,11 +388,6 @@ def _init_spreading_activation(
     vector_store: Any,
 ) -> Any | None:
     """Create SpreadingActivation for Phase 3 5th retrieval channel."""
-    # V3.3.21: Guard against None vector_store. Without embeddings, SA's
-    # search() crashes with "'NoneType' has no attribute 'search'".
-    if vector_store is None:
-        logger.debug("SpreadingActivation skipped: no vector_store")
-        return None
     try:
         from superlocalmemory.retrieval.spreading_activation import (
             SpreadingActivation,
@@ -552,29 +571,12 @@ def init_retrieval(
     # trust in slm health / slm doctor output.
     if reranker is not None:
         import threading
-        def _log_warmup_status() -> None:
-            ready = reranker.warmup_sync(timeout=180)
-            if ready:
-                logger.info("Cross-encoder reranker warm and ready")
-                return
-            # warmup_sync returned False. Could be (a) singleton held by
-            # another process (benign), or (b) actual model load failure.
-            # Disambiguate by probing the singleton PID file.
-            try:
-                from superlocalmemory.retrieval.reranker import _is_reranker_worker_alive
-                if _is_reranker_worker_alive():
-                    logger.info(
-                        "Cross-encoder reranker worker held by another process "
-                        "(machine-wide singleton — usually the unified daemon); "
-                        "this process will route reranking through that worker"
-                    )
-                    return
-            except Exception:
-                pass
-            logger.warning(
-                "Cross-encoder reranker warmup failed — recalls will use fallback scoring"
-            )
-        t = threading.Thread(target=_log_warmup_status, daemon=True, name="ce-init-warmup")
+        t = threading.Thread(
+            target=_log_reranker_warmup_status,
+            args=(reranker,),
+            daemon=True,
+            name="ce-init-warmup",
+        )
         t.start()
 
     # Phase A: Register forgetting filter into the channel registry

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/core/ram_lock.py

@@ -15,12 +15,13 @@ Design notes:
   available before we even try — better to defer than thrash.
 - Lock file lives at ``~/.superlocalmemory/ram_lock.sem`` by default,
   tests may monkeypatch ``RAM_LOCK_PATH``.
-- POSIX only; Windows build is deferred per LLD-00 §7 and MASTER-PLAN H-01.
+- Uses a standard-library advisory lock on POSIX and Windows.  The lock is
+  deliberately file-backed so independent daemon, CLI, and worker processes
+  share the same RAM reservation.
 """
 
 from __future__ import annotations
 
-import fcntl
 import os
 import time
 from contextlib import contextmanager
@@ -29,6 +30,11 @@ from typing import Iterator
 
 import psutil
 
+try:  # POSIX advisory locks (macOS/Linux)
+    import fcntl as _fcntl
+except ImportError:  # Windows uses the stdlib byte-range equivalent below.
+    _fcntl = None
+
 # Public override retained for tests and embedders. ``None`` means resolve the
 # lock dynamically so a long-lived process can switch canonical namespaces
 # without retaining the first root it observed.
@@ -44,6 +50,38 @@ def _ram_lock_path() -> Path:
     return state_path("ram_lock.sem")
 
 
+def _acquire_lock(fd: int) -> None:
+    """Acquire one non-blocking cross-process lock for the semaphore."""
+    if _fcntl is not None:
+        _fcntl.flock(fd, _fcntl.LOCK_EX | _fcntl.LOCK_NB)
+        return
+
+    import msvcrt
+
+    # ``msvcrt.locking`` cannot reserve an empty file.  The marker byte is
+    # purely structural; the human-readable audit marker is written after the
+    # reservation is acquired.
+    if os.fstat(fd).st_size == 0:
+        os.write(fd, b"\0")
+    os.lseek(fd, 0, os.SEEK_SET)
+    try:
+        msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+    except OSError as exc:
+        raise BlockingIOError("RAM reservation is already held") from exc
+
+
+def _release_lock(fd: int) -> None:
+    """Release a reservation acquired by :func:`_acquire_lock`."""
+    if _fcntl is not None:
+        _fcntl.flock(fd, _fcntl.LOCK_UN)
+        return
+
+    import msvcrt
+
+    os.lseek(fd, 0, os.SEEK_SET)
+    msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+
+
 @contextmanager
 def ram_reservation(
     name: str,
@@ -96,7 +134,7 @@ def ram_reservation(
         deadline = time.time() + timeout_s
         while True:
             try:
-                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                _acquire_lock(fd)
                 break
             except BlockingIOError:
                 if time.time() >= deadline:
@@ -114,7 +152,7 @@ def ram_reservation(
         yield
     finally:
         try:
-            fcntl.flock(fd, fcntl.LOCK_UN)
+            _release_lock(fd)
         finally:
             os.close(fd)
 

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/evolution/budget.py

@@ -20,7 +20,6 @@ Author: Varun Pratap Bhardwaj / Qualixar
 
 from __future__ import annotations
 
-import fcntl
 import logging
 import os
 import sqlite3
@@ -35,8 +34,44 @@ from superlocalmemory.core.security_primitives import safe_resolve_identifier
 
 logger = logging.getLogger(__name__)
 
+try:  # POSIX advisory locks (macOS/Linux)
+    import fcntl as _fcntl
+except ImportError:  # Windows has no fcntl; use its stdlib byte-range lock.
+    _fcntl = None
 
-# M-P-07: path-component hints for filesystems where ``fcntl.flock`` is
+
+def _acquire_profile_lock(fd: int) -> None:
+    """Acquire a non-blocking cross-process lock on every supported OS."""
+    if _fcntl is not None:
+        _fcntl.flock(fd, _fcntl.LOCK_EX | _fcntl.LOCK_NB)
+        return
+
+    import msvcrt
+
+    # ``msvcrt.locking`` cannot lock an empty file. Reserve one marker byte;
+    # the file content is diagnostic only and never a correctness signal.
+    if os.fstat(fd).st_size == 0:
+        os.write(fd, b"\0")
+    os.lseek(fd, 0, os.SEEK_SET)
+    try:
+        msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+    except OSError as exc:
+        raise BlockingIOError("evolution profile lock is held") from exc
+
+
+def _release_profile_lock(fd: int) -> None:
+    """Release the lock acquired by :func:`_acquire_profile_lock`."""
+    if _fcntl is not None:
+        _fcntl.flock(fd, _fcntl.LOCK_UN)
+        return
+
+    import msvcrt
+
+    os.lseek(fd, 0, os.SEEK_SET)
+    msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+
+
+# M-P-07: path-component hints for filesystems where advisory locking is
 # known to degrade to a no-op. We do NOT abort — some users accept the
 # risk — but we emit a one-shot warning so a double-cycle is at least
 # attributable to a known root cause. If/when we ship a threading-only
@@ -127,7 +162,7 @@ class EvolutionBudget:
         )
         self._lock_path = safe_stem.with_suffix(".lock")
         # M-P-07: warn once per lock-path when we detect the lock sits on
-        # a known sync-backed filesystem. ``fcntl.flock`` silently
+        # a known sync-backed filesystem. Advisory locking silently
         # degrades on iCloud/OneDrive/Dropbox — two concurrent cycles
         # would each acquire and burn LLM budget. Documentation-only for
         # now; a future release may refuse to run until the lock_dir is
@@ -141,7 +176,7 @@ class EvolutionBudget:
             if key not in _WARNED_SYNC_PATHS:
                 _WARNED_SYNC_PATHS.add(key)
                 logger.warning(
-                    "evolution lock at %s lives under %r — fcntl.flock "
+                    "evolution lock at %s lives under %r — advisory locking "
                     "may silently no-op on sync-backed filesystems. "
                     "Concurrent cycles could double-bill LLM cost. Move "
                     "the lock_dir off the sync root to make single-flight "
@@ -258,12 +293,12 @@ class EvolutionBudget:
                 f"cap={MAX_CYCLES_PER_DAY}",
             )
 
-        # Single-flight lock (non-blocking flock). A second concurrent
+        # Single-flight lock (non-blocking advisory lock). A second concurrent
         # acquire raises BlockingIOError — surface as BudgetExhausted.
         fd = os.open(str(self._lock_path), os.O_CREAT | os.O_RDWR, 0o600)
         try:
             try:
-                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                _acquire_profile_lock(fd)
             except BlockingIOError as e:
                 os.close(fd)
                 raise BudgetExhausted(
@@ -296,7 +331,7 @@ class EvolutionBudget:
             # Release lock before propagating — a failed cycle-record should
             # not leave the lock dangling.
             try:
-                fcntl.flock(fd, fcntl.LOCK_UN)
+                _release_profile_lock(fd)
             finally:
                 os.close(fd)
                 self._lock_fd = None
@@ -312,7 +347,7 @@ class EvolutionBudget:
         finally:
             self._cycle_start_mono = None
             try:
-                fcntl.flock(fd, fcntl.LOCK_UN)
+                _release_profile_lock(fd)
             finally:
                 try:
                     os.close(fd)

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/hooks/claude_code_hooks.py

@@ -40,7 +40,7 @@ _DEFAULT_DISABLED_FILE = _DEFAULT_VERSION_DIR / ".hooks-disabled"
 VERSION_DIR = _DEFAULT_VERSION_DIR
 VERSION_FILE = _DEFAULT_VERSION_FILE
 DISABLED_FILE = _DEFAULT_DISABLED_FILE
-HOOKS_VERSION = "3.7.0"
+HOOKS_VERSION = "3.7.1"
 
 # Cross-platform temp dir and backwards-compatible marker overrides. Runtime
 # defaults are root-namespaced and resolved when hook definitions are built.

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/hooks/context_payload.py

@@ -22,7 +22,7 @@ from typing import Callable, Iterable
 from superlocalmemory.core.security_primitives import redact_secrets
 
 
-VERSION = "3.7.0"
+VERSION = "3.7.1"
 DEFAULT_TOP_K = 10
 DEFAULT_DECISIONS_K = 5
 DEFAULT_MEMORIES_K = 10

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/mcp/http_transport.py

@@ -40,7 +40,7 @@ def install_streamable_http_resource_guard() -> None:
 class SLMFastMCP(FastMCP):
     """FastMCP with SLM release identity and deterministic SSE cleanup."""
 
-    def __init__(self, *args, product_version: str = "3.7.0", **kwargs) -> None:
+    def __init__(self, *args, product_version: str = "3.7.1", **kwargs) -> None:
         super().__init__(*args, **kwargs)
         # FastMCP delegates the initialize response to the low-level MCP
         # server. Without an explicit value it reports the installed ``mcp``

{superlocalmemory-3.7.0 → superlocalmemory-3.7.2}/src/superlocalmemory/mcp/tools_core.py

@@ -111,7 +111,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         """Store content to memory with intelligent indexing.
 
         Extracts atomic facts, resolves entities, builds graph edges,
-        and indexes for 4-channel retrieval.
+        and indexes for hybrid retrieval with graph-aware enhancement.
 
         Multi-scope: ``scope`` sets visibility (personal/shared/global).
         ``shared_with`` is a comma-separated list of profile_ids for
@@ -149,35 +149,52 @@ def register_core_tools(server, get_engine: Callable) -> None:
             # is_daemon_running() and daemon_request() both use blocking urllib
             # against the same uvicorn server — run in threads so the MCP
             # event loop stays unblocked (#34 class bug).
-            if await _asyncio.to_thread(is_daemon_running):
-                resp = await _asyncio.to_thread(daemon_request, "POST", "/remember", {
-                    "content": content, "tags": tags, "metadata": meta,
-                    "scope": scope, "shared_with": _shared_list,
-                    "session_id": session_id,
-                    "idempotency_key": effective_idempotency_key or None,
-                })
-                if resp and (resp.get("fact_ids") is not None or resp.get("ok")):
-                    fids = resp.get("fact_ids") or []
-                    materialization_state = resp.get("materialization_state")
-                    if materialization_state is None:
-                        materialization_state = (
-                            "complete" if resp.get("status") == "stored" else "queryable"
-                        )
-                    pending = materialization_state != "complete"
-                    return {
-                        "success": True,
-                        "fact_ids": fids,
-                        "count": int(resp.get("count", len(fids))),
-                        "pending": pending,
-                        "pending_id": resp.get("pending_id") if pending else None,
-                        "operation_id": resp.get("operation_id"),
-                        "materialization_state": materialization_state,
-                        "message": (
-                            "Stored through canonical daemon ingestion."
-                            if not pending
-                            else "Queryable now; canonical enrichment is still running."
-                        ),
-                    }
+            daemon_owned = await _asyncio.to_thread(is_daemon_running)
+            if daemon_owned:
+                # A positively identified daemon owns this database. Never
+                # spawn a WorkerPool writer after a transient daemon failure:
+                # that creates the competing writers which SQLite WAL cannot
+                # support. Retry the canonical path, then return an explicit
+                # retryable result to the MCP client.
+                for attempt in range(3):
+                    resp = await _asyncio.to_thread(daemon_request, "POST", "/remember", {
+                        "content": content, "tags": tags, "metadata": meta,
+                        "scope": scope, "shared_with": _shared_list,
+                        "session_id": session_id,
+                        "idempotency_key": effective_idempotency_key or None,
+                    })
+                    if resp and (resp.get("fact_ids") is not None or resp.get("ok")):
+                        fids = resp.get("fact_ids") or []
+                        materialization_state = resp.get("materialization_state")
+                        if materialization_state is None:
+                            materialization_state = (
+                                "complete" if resp.get("status") == "stored" else "queryable"
+                            )
+                        pending = materialization_state != "complete"
+                        return {
+                            "success": True,
+                            "fact_ids": fids,
+                            "count": int(resp.get("count", len(fids))),
+                            "pending": pending,
+                            "pending_id": resp.get("pending_id") if pending else None,
+                            "operation_id": resp.get("operation_id"),
+                            "materialization_state": materialization_state,
+                            "message": (
+                                "Stored through canonical daemon ingestion."
+                                if not pending
+                                else "Queryable now; canonical enrichment is still running."
+                            ),
+                        }
+                    if attempt < 2:
+                        await _asyncio.sleep(0.05 * (attempt + 1))
+                return {
+                    "success": False,
+                    "retryable": True,
+                    "error": (
+                        "Canonical daemon is temporarily unavailable; retry the "
+                        "same remember operation without starting a second writer."
+                    ),
+                }
         except Exception as dexc:
             logger.debug("MCP remember via daemon failed, pending fallback: %s", dexc)
 
@@ -246,7 +263,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         include_global: bool | None = None,
         include_shared: bool | None = None,
     ) -> dict:
-        """Search memories by semantic query with 4-channel retrieval, RRF fusion, and reranking.
+        """Search memories through hybrid retrieval, RRF fusion, and reranking.
 
         S9-DASH-02: optional ``session_id`` threads through to the
         engine's outcome-queue so PostToolUse / Stop hooks can attach