superlocalmemory 3.4.41__tar.gz → 3.4.43__tar.gz

{superlocalmemory-3.4.41/src/superlocalmemory.egg-info → superlocalmemory-3.4.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.41
+Version: 3.4.43
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -40,7 +40,6 @@ Requires-Dist: fastapi[all]>=0.135.1
 Requires-Dist: uvicorn>=0.42.0
 Requires-Dist: websockets>=16.0
 Requires-Dist: lightgbm>=4.0.0
-Requires-Dist: diskcache>=5.6.0
 Requires-Dist: orjson>=3.9.0
 Requires-Dist: tree-sitter<1,>=0.23.0
 Requires-Dist: tree-sitter-language-pack<1,>=0.5
@@ -49,11 +48,11 @@ Requires-Dist: watchdog<6,>=4.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: structlog<27.0.0,>=24.0.0
 Requires-Dist: portalocker<4.0.0,>=2.7.0
-Requires-Dist: sentence-transformers[onnx]>=5.0.0
+Requires-Dist: sentence-transformers[onnx]>=5.2.0
 Requires-Dist: torch>=2.2.0
 Requires-Dist: scikit-learn<2.0.0,>=1.3.0
 Provides-Extra: search
-Requires-Dist: sentence-transformers[onnx]>=5.0.0; extra == "search"
+Requires-Dist: sentence-transformers[onnx]>=5.2.0; extra == "search"
 Requires-Dist: einops>=0.8.2; extra == "search"
 Requires-Dist: torch>=2.2.0; extra == "search"
 Requires-Dist: scikit-learn<2.0.0,>=1.3.0; extra == "search"
@@ -66,7 +65,6 @@ Requires-Dist: python-multipart<1.0.0,>=0.0.6; extra == "ui"
 Provides-Extra: learning
 Requires-Dist: lightgbm>=4.0.0; extra == "learning"
 Provides-Extra: performance
-Requires-Dist: diskcache>=5.6.0; extra == "performance"
 Requires-Dist: orjson>=3.9.0; extra == "performance"
 Provides-Extra: ingestion
 Requires-Dist: keyring>=25.0.0; extra == "ingestion"
@@ -78,6 +76,7 @@ Requires-Dist: superlocalmemory[ingestion,learning,performance,search,ui]; extra
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
 Requires-Dist: sqlite-vec>=0.1.6; extra == "dev"
 Dynamic: license-file
 
@@ -317,6 +316,47 @@ All `--json` responses follow a consistent envelope with `success`, `command`, `
 
 ---
 
+## Smart-hook architecture (v3.4.43)
+
+SLM ships a small set of Claude Code hooks that fire memory operations only
+when there's a real signal — not on a timer, not on every keystroke. The
+hooks are perf-budgeted (<10ms p99 for the hot path) and fail-open (any
+crash → silent exit, never blocks your prompt). Install them with one
+command:
+
+```bash
+slm hooks install      # wires hooks into ~/.claude/settings.json
+slm hooks status       # shows what's installed
+slm hooks remove       # cleans up, preserves non-SLM hooks
+```
+
+| Hook | Event | When it fires | Why |
+|---|---|---|---|
+| `slm hook start` | SessionStart | Once at session boot | Injects core memory + recent context + learned patterns. ~80ms. |
+| `slm hook user_prompt_rehash` | UserPromptSubmit | Every prompt | Detects re-queries within 60s (negative signal that prior recall didn't satisfy). <10ms hot path. |
+| **`slm hook topic_shift`** *(new in 3.4.43)* | UserPromptSubmit | When current prompt shares zero content words with every prompt in a 5-turn sliding window | Surfaces a one-line "consider recall" hint on real topic pivots. Replaces the time-based 15-min nag — event-based, not timer-based. <10ms. |
+| **`slm hook before_web`** *(new in 3.4.43)* | PreToolUse on `WebSearch\|WebFetch` | Every web search/fetch | Runs `slm recall <query> --limit 5` and injects local memories as a system-reminder BEFORE the web call. Cost: ~500-800ms per fire, fires 5-20× per session. |
+| `slm hook checkpoint` | PostToolUse on `Write\|Edit` | Every file write/edit | Auto-observes file changes into SLM. No periodic nag (removed in v3.4.43). |
+| `slm hook post_tool_outcome` | PostToolUse (all tools) | Every tool call | Tracks which recalled facts got used (learning signal). |
+| `slm hook stop` | Stop | Session end | Saves rich session summary with git context. |
+
+**What "smart" means here:** the hooks don't interrupt you on a schedule.
+They watch for specific events that indicate memory work would add value —
+a topic pivot, a web call about to fire, a re-asked question, a file edit.
+Otherwise they stay out of your way.
+
+**Observability for the new hooks:**
+`topic_shift` writes one TSV line per decision to
+`~/.superlocalmemory/logs/topic-shift.log`
+(`timestamp | session_hash | current_words_count | window_depth | max_overlap |
+fired | prompt_preview`). Disable with `SLM_TOPIC_SHIFT_LOG=0`.
+
+**Upgrading from v3.4.42 or older:** Run `slm hooks install` once after
+upgrade to pull in the new wiring. `slm hooks status` will flag the
+version mismatch. Merge is idempotent — safe to run twice.
+
+---
+
 ## Three Operating Modes
 
 | Mode | What | Cloud? | EU AI Act | Best For |

{superlocalmemory-3.4.41 → superlocalmemory-3.4.43}/README.md

@@ -234,6 +234,47 @@ All `--json` responses follow a consistent envelope with `success`, `command`, `
 
 ---
 
+## Smart-hook architecture (v3.4.43)
+
+SLM ships a small set of Claude Code hooks that fire memory operations only
+when there's a real signal — not on a timer, not on every keystroke. The
+hooks are perf-budgeted (<10ms p99 for the hot path) and fail-open (any
+crash → silent exit, never blocks your prompt). Install them with one
+command:
+
+```bash
+slm hooks install      # wires hooks into ~/.claude/settings.json
+slm hooks status       # shows what's installed
+slm hooks remove       # cleans up, preserves non-SLM hooks
+```
+
+| Hook | Event | When it fires | Why |
+|---|---|---|---|
+| `slm hook start` | SessionStart | Once at session boot | Injects core memory + recent context + learned patterns. ~80ms. |
+| `slm hook user_prompt_rehash` | UserPromptSubmit | Every prompt | Detects re-queries within 60s (negative signal that prior recall didn't satisfy). <10ms hot path. |
+| **`slm hook topic_shift`** *(new in 3.4.43)* | UserPromptSubmit | When current prompt shares zero content words with every prompt in a 5-turn sliding window | Surfaces a one-line "consider recall" hint on real topic pivots. Replaces the time-based 15-min nag — event-based, not timer-based. <10ms. |
+| **`slm hook before_web`** *(new in 3.4.43)* | PreToolUse on `WebSearch\|WebFetch` | Every web search/fetch | Runs `slm recall <query> --limit 5` and injects local memories as a system-reminder BEFORE the web call. Cost: ~500-800ms per fire, fires 5-20× per session. |
+| `slm hook checkpoint` | PostToolUse on `Write\|Edit` | Every file write/edit | Auto-observes file changes into SLM. No periodic nag (removed in v3.4.43). |
+| `slm hook post_tool_outcome` | PostToolUse (all tools) | Every tool call | Tracks which recalled facts got used (learning signal). |
+| `slm hook stop` | Stop | Session end | Saves rich session summary with git context. |
+
+**What "smart" means here:** the hooks don't interrupt you on a schedule.
+They watch for specific events that indicate memory work would add value —
+a topic pivot, a web call about to fire, a re-asked question, a file edit.
+Otherwise they stay out of your way.
+
+**Observability for the new hooks:**
+`topic_shift` writes one TSV line per decision to
+`~/.superlocalmemory/logs/topic-shift.log`
+(`timestamp | session_hash | current_words_count | window_depth | max_overlap |
+fired | prompt_preview`). Disable with `SLM_TOPIC_SHIFT_LOG=0`.
+
+**Upgrading from v3.4.42 or older:** Run `slm hooks install` once after
+upgrade to pull in the new wiring. `slm hooks status` will flag the
+version mismatch. Merge is idempotent — safe to run twice.
+
+---
+
 ## Three Operating Modes
 
 | Mode | What | Cloud? | EU AI Act | Best For |

{superlocalmemory-3.4.41 → superlocalmemory-3.4.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.41"
+version = "3.4.43"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -42,7 +42,6 @@ dependencies = [
     "uvicorn>=0.42.0",
     "websockets>=16.0",
     "lightgbm>=4.0.0",
-    "diskcache>=5.6.0",
     "orjson>=3.9.0",
     # CodeGraph — code knowledge graph (v3.4)
     "tree-sitter>=0.23.0,<1",
@@ -57,7 +56,19 @@ dependencies = [
     # V3.4.18: Semantic search + cross-encoder reranker (npm install parity).
     # Previously under [search] extra — pip users silently lost 30pp of recall
     # quality vs. npm users. Now ships by default for both install paths.
-    "sentence-transformers[onnx]>=5.0.0",
+    # v3.4.43: bumped from >=5.0.0 to >=5.2.0 so the resolver doesn't pick
+    # 5.0.0-5.1.2 which cap transformers<5.0.0 (security headroom for when
+    # optimum-onnx upstream eventually supports transformers 5.x).
+    "sentence-transformers[onnx]>=5.2.0",
+    # NOTE on CVE-2026-1839 (transformers Trainer.torch.load RCE):
+    # SLM does NOT use transformers.Trainer (inference-only path via
+    # sentence-transformers + ONNX backend). The vulnerable method
+    # Trainer._load_rng_state is never called by SLM code, so the CVE is
+    # unreachable through SLM's API surface. We CANNOT pin transformers>=5.0.0
+    # because optimum-onnx 0.1.0 (latest upstream) caps transformers<4.58.0
+    # and SLM's embedding_worker.py:68 hard-codes backend="onnx". Will
+    # tighten this pin in a future release once optimum-onnx ships a
+    # transformers-5.x-compatible build.
     "torch>=2.2.0",
     "scikit-learn>=1.3.0,<2.0.0",
 ]
@@ -67,7 +78,7 @@ dependencies = [
 # moved into core in v3.4.18. ``pip install superlocalmemory[search]`` still
 # works but installs nothing extra.
 search = [
-    "sentence-transformers[onnx]>=5.0.0",
+    "sentence-transformers[onnx]>=5.2.0",
     "einops>=0.8.2",
     "torch>=2.2.0",
     "scikit-learn>=1.3.0,<2.0.0",
@@ -83,7 +94,6 @@ learning = [
     "lightgbm>=4.0.0",
 ]
 performance = [
-    "diskcache>=5.6.0",
     "orjson>=3.9.0",
 ]
 ingestion = [
@@ -98,6 +108,7 @@ full = [
 dev = [
     "pytest>=8.0",
     "pytest-cov>=4.1",
+    "pytest-asyncio>=0.21",
     "sqlite-vec>=0.1.6",
 ]
 
@@ -124,10 +135,12 @@ superlocalmemory = ["ui/**/*", "skills/**/*"]
 testpaths = ["tests"]
 pythonpath = ["src"]
 addopts = "-m 'not slow and not ollama and not benchmark'"
+asyncio_mode = "auto"
 markers = [
     "slow: marks tests as slow — real engine/model loading (run with: pytest -m slow)",
     "ollama: marks tests that require a running Ollama instance",
     "benchmark: marks CI-only evo-memory benchmark tests (run with: pytest tests/test_benchmarks/ -m benchmark)",
+    "asyncio: marks tests as async — runs via pytest-asyncio (auto-mode in this project)",
 ]
 filterwarnings = [
     "ignore::DeprecationWarning:vaderSentiment",
@@ -167,5 +180,6 @@ select = ["E", "F", "I", "W"]
 dev = [
     "build>=1.4.0",
     "pytest>=9.0.2",
+    "pytest-asyncio>=0.21",
     "twine>=6.2.0",
 ]

{superlocalmemory-3.4.41 → superlocalmemory-3.4.43}/src/superlocalmemory/cli/commands.py

@@ -316,9 +316,16 @@ def cmd_restart(args: Namespace) -> None:
          f"removed: {', '.join(cleaned)}" if cleaned else "already clean")
 
     # Step 3: Start fresh daemon (lock still held — no races)
+    # v3.4.42: Call _start_daemon_subprocess() directly instead of
+    # ensure_daemon(). The latter tries to acquire daemon.lock itself,
+    # which the SAME PROCESS holds via restart_lock_fd above — BSD-style
+    # flock blocks per-fd even within one process, so ensure_daemon would
+    # fall into its lock-fail branch and time out after 60s while the
+    # actual daemon never gets started. Calling the helper directly
+    # bypasses that self-deadlock and starts the daemon as intended.
     time.sleep(1)
-    from superlocalmemory.cli.daemon import ensure_daemon
-    started = ensure_daemon()
+    from superlocalmemory.cli.daemon import _start_daemon_subprocess
+    started = _start_daemon_subprocess()
 
     # Release restart lock — daemon is now running with its own lock
     if restart_lock_fd:
@@ -622,24 +629,53 @@ def cmd_setup(args: Namespace) -> None:
 
 
 def cmd_mode(args: Namespace) -> None:
-    """Get or set the operating mode."""
+    """Get or set the operating mode.
+
+    v3.4.43 behavior change: switching modes via this CLI now PRESERVES the
+    user's existing embedding, retrieval, evolution, forgetting, and math
+    settings. Previously the CLI called ``SLMConfig.for_mode(...)`` which
+    re-derived every field from mode defaults — silently clobbering user
+    customizations (e.g. a tuned cross-encoder model, a custom embedding
+    endpoint, or custom forgetting half-lives). The v3.4.34 ``mode_change=True``
+    guard only protected the ``mode`` field itself; everything else was lost.
+
+    New rules:
+      - Only ``config.mode`` changes.
+      - If the user has NO LLM provider configured AND is switching to a mode
+        that typically needs one (B or C), mode-appropriate LLM defaults are
+        populated to avoid the daemon coming up dead. Existing LLM config
+        is preserved as-is.
+      - Embedding / retrieval / evolution / forgetting / math: untouched.
+    """
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.storage.models import Mode
 
     config = SLMConfig.load()
 
+    def _apply_mode_change(new_value: str) -> tuple[SLMConfig, bool]:
+        """Mutate-in-place mode switch. Returns (updated_config, llm_was_set).
+
+        Only changes ``config.mode``. If the user has no LLM provider
+        configured AND is moving to Mode B or C, populates the mode's
+        default LLM block so the daemon has something to talk to.
+        Everything else (embedding, retrieval, evolution, forgetting,
+        math, profile) is preserved byte-for-byte.
+        """
+        new_mode = Mode(new_value)
+        llm_was_set = False
+        if new_mode != Mode.A and not config.llm.provider:
+            defaults = SLMConfig.for_mode(new_mode)
+            config.llm = defaults.llm
+            llm_was_set = True
+        config.mode = new_mode
+        config.save(mode_change=True)
+        return config, llm_was_set
+
     if getattr(args, 'json', False):
         from superlocalmemory.cli.json_output import json_print
         if args.value:
             old_mode = config.mode.value.upper()
-            updated = SLMConfig.for_mode(
-                Mode(args.value),
-                llm_provider=config.llm.provider,
-                llm_model=config.llm.model,
-                llm_api_key=config.llm.api_key,
-                llm_api_base=config.llm.api_base,
-            )
-            updated.save(mode_change=True)
+            updated, _ = _apply_mode_change(args.value)
             json_print("mode", data={
                 "previous_mode": old_mode, "current_mode": args.value.upper(),
             }, next_actions=[
@@ -654,20 +690,18 @@ def cmd_mode(args: Namespace) -> None:
         return
 
     if args.value:
-        updated = SLMConfig.for_mode(
-            Mode(args.value),
-            llm_provider=config.llm.provider,
-            llm_model=config.llm.model,
-            llm_api_key=config.llm.api_key,
-            llm_api_base=config.llm.api_base,
-        )
-        updated.save(mode_change=True)
+        updated, llm_was_set = _apply_mode_change(args.value)
         print(f"Mode set to: {args.value.upper()}")
 
-        # V3.3: Check if embedding model changed — inform about re-indexing
-        if (config.embedding.provider != updated.embedding.provider
-                or config.embedding.model_name != updated.embedding.model_name):
-            print("  ⚠ Embedding model changed. Re-indexing will run on next recall.")
+        # v3.4.43: embedding/retrieval are now preserved, so the old
+        # "Embedding model changed. Re-indexing will run on next recall."
+        # warning no longer fires from a CLI mode switch — that was the
+        # symptom of the bug. The warning is retained ONLY as an
+        # informational note when LLM defaults were freshly populated.
+        if llm_was_set:
+            print(f"  ℹ LLM provider populated from mode defaults: "
+                  f"{updated.llm.provider}/{updated.llm.model}. "
+                  f"Run `slm provider set` to customize.")
 
         # V3.3.4: Warn if Mode C lacks cloud API key
         if args.value == "c" and not updated.llm.api_key:
@@ -1415,19 +1449,22 @@ def cmd_doctor(args: Namespace) -> None:
                "brew install libomp && pip install --force-reinstall lightgbm")
 
     # 6. Performance deps
+    # v3.4.43: diskcache removed from this check — it was a phantom dependency
+    # (declared in pyproject.toml but never imported anywhere in src/ or tests/).
+    # Dropping it closes CVE-2025-69872 (pickle deserialization RCE) without any
+    # behavior change. orjson remains a real performance dep.
     perf_ok = []
-    for mod in ["diskcache", "orjson"]:
+    for mod in ["orjson"]:
         try:
             __import__(mod)
             perf_ok.append(mod)
         except ImportError:
             pass
-    if len(perf_ok) == 2:
-        _check("Performance deps", "PASS", "diskcache, orjson")
+    if perf_ok:
+        _check("Performance deps", "PASS", "orjson")
     else:
-        missing = {"diskcache", "orjson"} - set(perf_ok)
-        _check("Performance deps", "WARN", f"Missing: {', '.join(missing)}",
-               "pip install diskcache orjson")
+        _check("Performance deps", "WARN", "Missing: orjson",
+               "pip install orjson")
 
     # 7. Embedding worker functional test — skipped under --quick.
     if quick:
@@ -1662,7 +1699,19 @@ def cmd_mcp(_args: Namespace) -> None:
 
 
 def cmd_warmup(_args: Namespace) -> None:
-    """Pre-download the embedding model so first use is instant."""
+    """Pre-download the embedding model so first use is instant.
+
+    v3.4.42: daemon-aware. The embedding worker is a machine-wide
+    singleton (`_is_embedding_worker_alive` + PID file), so when the
+    unified daemon is running it OWNS the worker. A fresh
+    `EmbeddingService` started here would see the singleton, set
+    `_available = False`, return None from `_subprocess_embed`, and
+    print "embedding verification failed" — even though the daemon's
+    worker is already happily serving the same model. The fix: detect
+    the daemon, verify via its health endpoint, and skip the local
+    spawn. Only fall through to the original local-worker path when
+    the daemon is genuinely unreachable.
+    """
     import superlocalmemory.core.embeddings as _emb_mod
 
     print("SuperLocalMemory V3 — Embedding Model Warmup")
@@ -1671,7 +1720,37 @@ def cmd_warmup(_args: Namespace) -> None:
     print(f"  Model:  nomic-ai/nomic-embed-text-v1.5 (~500MB)")
     print()
 
-    # Increase timeout for first-time download
+    # v3.4.42 — daemon-aware fast path. If the daemon is up and reports
+    # engine=initialized, the embedding model is already loaded inside
+    # the daemon's worker subprocess. No need to spawn a redundant one;
+    # in fact, the machine-wide singleton would refuse to do so anyway.
+    try:
+        from superlocalmemory.cli.daemon import (
+            is_daemon_running, daemon_request,
+        )
+        if is_daemon_running():
+            health = daemon_request("GET", "/health")
+            if health and health.get("engine") == "initialized":
+                from superlocalmemory.core.config import EmbeddingConfig
+                cfg = EmbeddingConfig()
+                print("[PASS] Daemon is running with embedding model loaded.")
+                print(f"       Model: {cfg.model_name} ({cfg.dimension}-dim)")
+                print("Semantic search is fully operational.")
+                return
+            # Daemon up but engine not yet initialized — warn and return
+            # rather than racing the daemon for the singleton lock.
+            engine_state = (health or {}).get("engine", "unknown")
+            print(f"[INFO] Daemon is up but engine state is '{engine_state}'.")
+            print("       Wait ~30s and retry, or run: slm doctor")
+            return
+    except Exception:
+        # Any failure in the daemon path falls through to local warmup —
+        # better to spawn a local worker than block warmup entirely.
+        pass
+
+    # Local-warmup fallback path: daemon is unreachable, so it's safe
+    # to spawn our own embedding worker (no singleton conflict).
+    # Increase timeout for first-time download.
     original_timeout = _emb_mod._SUBPROCESS_RESPONSE_TIMEOUT
     _emb_mod._SUBPROCESS_RESPONSE_TIMEOUT = 180  # 3 min for cold start
 

{superlocalmemory-3.4.41 → superlocalmemory-3.4.43}/src/superlocalmemory/cli/daemon.py

@@ -137,6 +137,50 @@ def daemon_request(method: str, path: str, body: dict | None = None) -> dict | N
 _LOCK_FILE = Path.home() / ".superlocalmemory" / "daemon.lock"
 
 
+def _start_daemon_subprocess() -> bool:
+    """Spawn the unified daemon subprocess and wait for readiness.
+
+    v3.4.42: Extracted from ensure_daemon() so callers that already hold
+    daemon.lock (e.g. cmd_restart Step 2) can start the daemon WITHOUT
+    triggering a second flock acquisition. BSD-style flock blocks per-fd
+    even within the same process, so the previous code path produced a
+    self-deadlock when called from Step 3 of `slm restart`: the lock held
+    by Step 2 caused ensure_daemon's own flock to fail with EWOULDBLOCK,
+    falling into the wait-for-someone-else branch and timing out at 60s
+    even though the daemon would have started cleanly.
+
+    PRECONDITION: caller has either acquired daemon.lock OR is certain no
+    other CLI/MCP process is racing to start a daemon (e.g. we just killed
+    everything in `slm restart` Step 1).
+
+    Returns True if daemon is reachable on the health endpoint within
+    60 seconds, False otherwise.
+    """
+    if is_daemon_running():
+        return True
+
+    import subprocess
+    cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
+    log_dir = Path.home() / ".superlocalmemory" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "daemon.log"
+
+    kwargs: dict = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    else:
+        kwargs["start_new_session"] = True
+
+    with open(log_file, "a") as lf:
+        proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
+
+    # Write PID immediately so other callers see it during warmup
+    _PID_FILE.write_text(str(proc.pid))
+    _PORT_FILE.write_text(str(_DEFAULT_PORT))
+
+    return _wait_for_daemon(timeout=60)
+
+
 def ensure_daemon() -> bool:
     """Start daemon if not running. Returns True if daemon is ready.
 
@@ -145,6 +189,12 @@ def ensure_daemon() -> bool:
       2. File lock prevents two callers from starting concurrent daemons
       3. After starting, waits for PID file (not health check) — fast detection
       4. Cross-platform: macOS + Windows + Linux
+
+    v3.4.42: Refactored to delegate the actual subprocess start to
+    `_start_daemon_subprocess()`. Callers that already hold daemon.lock
+    (e.g. `slm restart` Step 3) should call that helper directly to avoid
+    the same-process flock self-deadlock that returned a false-negative
+    "failed to start" while the daemon was actually starting cleanly.
     """
     if is_daemon_running():
         return True
@@ -176,27 +226,9 @@ def ensure_daemon() -> bool:
         if is_daemon_running():
             return True
 
-        # Start unified daemon in background
-        import subprocess
-        cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
-        log_dir = Path.home() / ".superlocalmemory" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_file = log_dir / "daemon.log"
-
-        kwargs: dict = {}
-        if sys.platform == "win32":
-            kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
-        else:
-            kwargs["start_new_session"] = True
-
-        with open(log_file, "a") as lf:
-            proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
-
-        # Write PID immediately so other callers see it during warmup
-        _PID_FILE.write_text(str(proc.pid))
-        _PORT_FILE.write_text(str(_DEFAULT_PORT))
-
-        return _wait_for_daemon(timeout=60)
+        # Start unified daemon in background — delegated to helper so the
+        # same logic can be reused by callers that already hold the lock.
+        return _start_daemon_subprocess()
 
     except Exception as exc:
         # Daemon auto-start is the entry point for dashboard / mesh /

{superlocalmemory-3.4.41 → superlocalmemory-3.4.43}/src/superlocalmemory/core/engine_wiring.py

@@ -559,14 +559,39 @@ def init_retrieval(
     # The CrossEncoderReranker constructor starts background warmup, but
     # callers can also call warmup_sync() to block until ready.
     # Here we just log warmup status — benchmark scripts call warmup_sync() explicitly.
+    #
+    # v3.4.42: Distinguish the legitimate "another process owns the
+    # reranker worker" case (machine-wide singleton — usually the unified
+    # daemon) from a real warmup failure. Before this fix, any CLI process
+    # that wired an Engine while the daemon was up would log
+    # "reranker warmup failed — recalls will use fallback scoring" even
+    # though the daemon's reranker was healthy and serving fine. The
+    # warning was a false positive that masked real failures and eroded
+    # 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")
-            else:
-                logger.warning("Cross-encoder reranker warmup failed — recalls will use fallback scoring")
+                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.start()