superlocalmemory 3.7.8 → 3.8.1

package/src/superlocalmemory/core/embeddings.py

@@ -7,8 +7,8 @@
 All PyTorch/model work runs in a SEPARATE subprocess. The main process
 (dashboard, MCP, CLI) never imports torch and stays at ~60 MB.
 
-The worker subprocess auto-kills after 2 minutes idle, returning all
-memory to the OS. It respawns on next embed call (~3 sec cold start).
+The worker subprocess has a configurable idle timeout and respawns on the
+next embed call when it has been unloaded.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
 """
@@ -29,14 +29,14 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 
+from superlocalmemory.core.config import EmbeddingConfig
+
 # Track all live embedding services for atexit cleanup
 _live_embedding_services: set[weakref.ref] = set()
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-from superlocalmemory.core.config import EmbeddingConfig
-
 logger = logging.getLogger(__name__)
 
 # Fisher variance constants
@@ -63,6 +63,7 @@ class DimensionMismatchError(RuntimeError):
 
 _MAX_CONCURRENT_WORKERS = int(os.environ.get("SLM_MAX_EMBEDDING_WORKERS", 1))
 _embedding_lock_fd: int | None = None
+_embedding_lock_state_guard = threading.Lock()
 
 
 def _embedding_lock_file() -> Path:
@@ -106,57 +107,87 @@ def register_embedding_worker_pid(pid: int) -> None:
 def acquire_embedding_lock(timeout: float = 5.0) -> bool:
     """Acquire system-wide embedding worker lock.
 
-    v3.4.13: First checks if a worker PID is already alive (fast path).
-    Falls back to fcntl.flock on Unix. On Windows, falls back to PID check only.
+    The caller must re-check the PID file after acquisition before spawning.
+    POSIX uses flock; Windows uses a one-byte msvcrt lock.
     Returns True if lock acquired (safe to spawn), False if another worker active.
     """
     global _embedding_lock_fd
 
-    # v3.4.13: Fast path — if a worker PID is alive, don't even try the lock
-    if _is_embedding_worker_alive():
-        return False
-
-    if sys.platform == "win32":
-        return True  # No file locking on Windows — PID check above is the guard
-
-    import fcntl
-    lock_file = _embedding_lock_file()
-    lock_file.parent.mkdir(parents=True, exist_ok=True)
+    # Serialize local contenders as well as cross-process contenders. The file
+    # descriptor stays local until its OS lock succeeds, so a failed acquire
+    # can never overwrite and leak the descriptor that owns the live worker.
+    with _embedding_lock_state_guard:
+        if _embedding_lock_fd is not None:
+            return False
+        if _is_embedding_worker_alive():
+            return False
 
-    try:
-        _embedding_lock_fd = os.open(str(lock_file), os.O_CREAT | os.O_RDWR)
-        deadline = time.time() + timeout
-        while time.time() < deadline:
-            try:
-                fcntl.flock(_embedding_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                return True
-            except (BlockingIOError, OSError):
-                time.sleep(0.2)
-        # Timeout — another worker holds the lock
-        os.close(_embedding_lock_fd)
-        _embedding_lock_fd = None
-        return False
-    except Exception:
-        return True  # On error, allow through (don't block functionality)
+        lock_file = _embedding_lock_file()
+        lock_file.parent.mkdir(parents=True, exist_ok=True)
+        candidate_fd: int | None = None
+        try:
+            candidate_fd = os.open(str(lock_file), os.O_CREAT | os.O_RDWR)
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                try:
+                    if sys.platform == "win32":
+                        import msvcrt
+
+                        if os.fstat(candidate_fd).st_size == 0:
+                            os.write(candidate_fd, b"\0")
+                        os.lseek(candidate_fd, 0, os.SEEK_SET)
+                        msvcrt.locking(candidate_fd, msvcrt.LK_NBLCK, 1)
+                    else:
+                        import fcntl
+
+                        fcntl.flock(
+                            candidate_fd,
+                            fcntl.LOCK_EX | fcntl.LOCK_NB,
+                        )
+                    _embedding_lock_fd = candidate_fd
+                    return True
+                except (BlockingIOError, OSError):
+                    time.sleep(0.2)
+            os.close(candidate_fd)
+            return False
+        except Exception:
+            if candidate_fd is not None:
+                try:
+                    os.close(candidate_fd)
+                except OSError:
+                    pass
+            return False
 
 
 def release_embedding_lock() -> None:
     """Release system-wide embedding worker lock."""
     global _embedding_lock_fd
-    if _embedding_lock_fd is not None:
+    with _embedding_lock_state_guard:
+        if _embedding_lock_fd is None:
+            return
         try:
-            import fcntl
-            fcntl.flock(_embedding_lock_fd, fcntl.LOCK_UN)
+            if sys.platform == "win32":
+                import msvcrt
+
+                os.lseek(_embedding_lock_fd, 0, os.SEEK_SET)
+                msvcrt.locking(_embedding_lock_fd, msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(_embedding_lock_fd, fcntl.LOCK_UN)
             os.close(_embedding_lock_fd)
         except Exception:
-            pass
+            try:
+                os.close(_embedding_lock_fd)
+            except OSError:
+                pass
         _embedding_lock_fd = None
 
 
-_IDLE_TIMEOUT_SECONDS = 300  # 5 minutes — balance cold-start vs RAM.
-# V3.4.37: Reduced from 1800 → 300. Holding 1.1 GB for 30 min idle
-# wastes RAM on laptops. 5 min covers bursty session_init+recall
-# patterns while freeing memory between sessions.
+_IDLE_TIMEOUT_SECONDS = 1800  # 30 minutes — keep interactive sessions warm.
+# V3.8.1: existing-user soaks showed that the five-minute policy repeatedly
+# recycled a ~1.1 GB local model and imposed 20-30 second cold starts. The
+# explicit environment override remains available for low-RAM installations.
 _IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_EMBED_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
 # V3.3.21: Configurable response timeout — 180s default, but batch ingestion
 # (2-turn chunks across 10 conversations) needs 600s+ to survive cold-start
@@ -186,6 +217,7 @@ class EmbeddingService:
         self._last_used: float = 0.0
         self._idle_timer: threading.Timer | None = None
         self._worker_ready = False
+        self._owns_worker_lock = False
         self._request_count: int = 0
         self._http_client: object | None = None
 
@@ -295,7 +327,13 @@ class EmbeddingService:
         never hangs indefinitely on cold model loads or network issues.
         """
         with self._lock:
-            if not self._available:
+            # Only an explicit terminal disable (``False``) short-circuits. A
+            # ``None`` availability is the recall-health self-heal's "re-probe"
+            # signal (recall_health._heal_embedder) — it must fall through and
+            # respawn the worker, matching OllamaEmbedder's tri-state
+            # convention. Using ``not self._available`` here bricked the local
+            # worker on the first heal tick, because ``None`` is falsy.
+            if self._available is False:
                 return None
             # Worker recycling: restart after N requests to prevent
             # C++ allocator fragmentation over long-running sessions.
@@ -348,6 +386,11 @@ class EmbeddingService:
                     self._available = False
                     self._kill_worker()
                     return None
+                # A successful embed proves the worker is healthy, so clear any
+                # transient/``None`` availability left by a self-heal re-probe
+                # back to a definite ``True``. Without this the flag lingers at
+                # ``None`` and the next ``not``-style check elsewhere re-blocks.
+                self._available = True
                 self._reset_idle_timer()
                 self._request_count += 1
                 return resp["vectors"]
@@ -467,18 +510,32 @@ class EmbeddingService:
         v3.4.13: Machine-wide singleton — checks PID file before spawning.
         Only ONE embedding_worker can exist at a time on the machine.
         """
-        if self._worker_proc is not None and self._worker_proc.poll() is None:
-            return
-        self._worker_proc = None
+        if self._worker_proc is not None:
+            if self._worker_proc.poll() is None:
+                return
+            # An unexpectedly exited child still leaves this service holding
+            # its lifetime flock. Fully close the dead process and release that
+            # lock before attempting the normal acquire/spawn sequence. Merely
+            # dropping the Popen reference makes the process deadlock against
+            # its own old flock until the acquire timeout expires.
+            self._kill_worker()
 
-        # v3.4.13: Check if another worker is already alive (machine-wide)
+        # Serialize the check/spawn/register sequence across processes. Checking
+        # the PID file without this lock allows two cold callers to both see no
+        # worker and launch memory-heavy children.
+        if not acquire_embedding_lock():
+            logger.debug("Embedding worker owned by another process")
+            self._available = False
+            return
         if _is_embedding_worker_alive():
-            logger.debug("Embedding worker already alive (PID file), skipping spawn")
+            release_embedding_lock()
+            logger.debug("Embedding worker already alive after lock acquisition")
             self._available = False
             return
 
         # V3.3.28: Check memory pressure before spawning
         if not self._check_memory_pressure():
+            release_embedding_lock()
             logger.warning("Skipping embedding worker spawn due to memory pressure")
             self._available = False
             return
@@ -513,9 +570,23 @@ class EmbeddingService:
             )
             # v3.4.13: Register PID for machine-wide singleton guard
             register_embedding_worker_pid(self._worker_proc.pid)
+            self._owns_worker_lock = True
             logger.info("Embedding worker spawned (PID %d)", self._worker_proc.pid)
             self._worker_ready = True
         except Exception as exc:
+            failed_proc = self._worker_proc
+            if failed_proc is not None:
+                try:
+                    failed_proc.terminate()
+                    failed_proc.wait(timeout=3)
+                except Exception:
+                    try:
+                        failed_proc.kill()
+                        failed_proc.wait(timeout=3)
+                    except Exception:
+                        pass
+            release_embedding_lock()
+            self._owns_worker_lock = False
             logger.warning(
                 "Failed to spawn embedding worker: %s. "
                 "Run 'slm doctor' to verify your Python environment. "
@@ -565,9 +636,23 @@ class EmbeddingService:
                             stream.close()
                         except (BrokenPipeError, OSError, ValueError):
                             pass
+        if getattr(self, "_owns_worker_lock", False):
+            try:
+                pid_file = _embedding_pid_file()
+                if (
+                    proc is not None
+                    and pid_file.exists()
+                    and pid_file.read_text().strip() == str(proc.pid)
+                ):
+                    pid_file.unlink(missing_ok=True)
+            except (OSError, ValueError):
+                pass
+            finally:
+                self._owns_worker_lock = False
+                release_embedding_lock()
 
     def _reset_idle_timer(self) -> None:
-        """Reset idle timer — kills worker after 2 min inactivity."""
+        """Reset the configurable worker-idle timer."""
         if self._idle_timer is not None:
             self._idle_timer.cancel()
         self._idle_timer = threading.Timer(

package/src/superlocalmemory/core/engine.py

@@ -180,6 +180,15 @@ class MemoryEngine:
         except Exception as exc:
             logger.warning("V3.4.6 schema migration failed: %s", exc)
 
+        # V3.4.7: Apply "Learning Brain" schema before deferred migrations.
+        # M029 adds composite history indexes to these runtime tables, so the
+        # tables must exist before the migration runner records M029 complete.
+        try:
+            from superlocalmemory.storage.schema_v347 import apply_v347_schema
+            apply_v347_schema(str(self._db.db_path))
+        except Exception as exc:
+            logger.warning("V3.4.7 schema migration failed: %s", exc)
+
         # v3.6.15: apply ALL pending migrations — including DEFERRED ones like
         # M016 (scope/shared_with columns) — for DIRECT-engine usage: `slm
         # remember --sync`, the Python API, and LangChain/CrewAI integrations.
@@ -213,13 +222,6 @@ class MemoryEngine:
                 f"ingestion migration failed: {exc}"
             ) from exc
 
-        # V3.4.7: Apply "Learning Brain" schema (tool_events, behavioral_assertions)
-        try:
-            from superlocalmemory.storage.schema_v347 import apply_v347_schema
-            apply_v347_schema(str(self._db.db_path))
-        except Exception as exc:
-            logger.warning("V3.4.7 schema migration failed: %s", exc)
-
         # V3.4.10: Apply "Fortress" schema (backup_destinations, entity_blacklist)
         try:
             from superlocalmemory.storage.schema_v3410 import apply_v3410_schema
@@ -276,6 +278,18 @@ class MemoryEngine:
                 )
                 self._llm = None
 
+        # H-03 (3.7.9): surface mode-capability degradation explicitly at
+        # startup. validate_mode_config existed but was never called, so Mode B
+        # silently using rule-based extraction after Ollama vanished (update,
+        # restart, port conflict) went unwarned. Each mode only checks its own
+        # capabilities, so passing the single llm-availability signal is safe.
+        from superlocalmemory.core.modes import validate_mode_config
+        _llm_up = getattr(self, "_llm", None) is not None
+        for _warning in validate_mode_config(
+            self._config.mode, has_ollama=_llm_up, has_cloud_llm=_llm_up,
+        ):
+            logger.warning("Mode config: %s", _warning)
+
         from superlocalmemory.trust.scorer import TrustScorer
         from superlocalmemory.trust.provenance import ProvenanceTracker
         from superlocalmemory.compliance.eu_ai_act import EUAIActChecker
@@ -348,16 +362,17 @@ class MemoryEngine:
 
         self._check_embedding_migration()
 
-        # V3.3.13: Background maintenance scheduler (Langevin/Ebbinghaus/Sheaf)
-        if self._config.forgetting.enabled:
-            try:
-                from superlocalmemory.core.maintenance_scheduler import MaintenanceScheduler
-                self._maintenance_scheduler = MaintenanceScheduler(
-                    self._db, self._config, self._profile_id,
-                )
-                self._maintenance_scheduler.start()
-            except Exception as exc:
-                logger.debug("Maintenance scheduler init failed: %s", exc)
+        # Lifecycle/tier evaluation, bounded housekeeping, and backup checks
+        # must continue even when optional forgetting/math maintenance is
+        # disabled. The scheduler itself gates those optional calculations.
+        try:
+            from superlocalmemory.core.maintenance_scheduler import MaintenanceScheduler
+            self._maintenance_scheduler = MaintenanceScheduler(
+                self._db, self._config, self._profile_id,
+            )
+            self._maintenance_scheduler.start()
+        except Exception as exc:
+            logger.debug("Maintenance scheduler init failed: %s", exc)
 
     def _process_pending_memories(self) -> None:
         """Process pending memories from store-first async pattern.
@@ -374,7 +389,9 @@ class MemoryEngine:
             return
 
         base_dir = self._config.base_dir
-        pending = get_pending(base_dir, limit=20)
+        # Only drain items enqueued under THIS engine's profile — a queued
+        # memory must never materialize under a profile it was not written for.
+        pending = get_pending(base_dir, limit=20, profile_id=self.profile_id)
         if not pending:
             return
 
@@ -599,6 +616,7 @@ class MemoryEngine:
         *,
         include_global: bool | None = None,
         include_shared: bool | None = None,
+        window: str | tuple[str, str] | None = None,
     ) -> RecallResponse:
         """Recall relevant facts for a query.
 
@@ -609,10 +627,10 @@ class MemoryEngine:
         ``put_nowait`` and the actual ``pending_outcomes`` INSERT runs
         on a background worker.
 
-        ``fast=True`` is the latency-bounded path: it skips spreading
-        activation and remote agentic verification while retaining semantic,
-        lexical, graph, temporal, and Hopfield retrieval. Use full recall when
-        maximum multi-round quality matters more than response time.
+        ``fast=True`` is the latency-bounded path: it retains all six local
+        retrieval channels but skips remote agentic verification. Use
+        ``fast=False`` only when maximum multi-round quality matters more than
+        response time.
 
         Multi-scope: ``include_global`` / ``include_shared`` control which
         scopes participate in retrieval. ``None`` (the default) means "use the
@@ -650,6 +668,7 @@ class MemoryEngine:
                 fast=fast,
                 include_global=include_global,
                 include_shared=include_shared,
+                window=window,
             )
         except Exception as exc:
             from superlocalmemory.infra.local_diagnostics import record_operation