superlocalmemory 3.4.11 → 3.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.11",
+  "version": "3.4.13",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.11"
+version = "3.4.13"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/cli/commands.py

@@ -230,20 +230,43 @@ def cmd_restart(args: Namespace) -> None:
     _log(1, "Kill all SLM processes", "ok", f"{killed} processes killed")
     time.sleep(3)
 
-    # Step 2: Clean stale files
+    # Step 2: Clean stale files + HOLD the lock to prevent races
+    # v3.4.13: Do NOT delete daemon.lock — HOLD it instead.
+    # If we delete it, `slm mcp` (still running in Claude) will see no lock,
+    # acquire a NEW lock, and start a second daemon during our restart.
     cleaned = []
-    for fname in ("daemon.pid", "daemon.port", "daemon.lock"):
+    for fname in ("daemon.pid", "daemon.port", ".embedding-worker.pid", ".reranker-worker.pid"):
         fpath = slm_dir / fname
         if fpath.exists():
             fpath.unlink(missing_ok=True)
             cleaned.append(fname)
+
+    # Hold the lock file to block other processes from starting a daemon
+    _LOCK_FILE = slm_dir / "daemon.lock"
+    _LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+    restart_lock_fd = None
+    try:
+        restart_lock_fd = open(_LOCK_FILE, "w")
+        if sys.platform != "win32":
+            import fcntl
+            fcntl.flock(restart_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except Exception:
+        pass  # Best-effort — don't block restart if lock fails
+
     _log(2, "Clean stale state files", "ok",
          f"removed: {', '.join(cleaned)}" if cleaned else "already clean")
 
-    # Step 3: Start fresh daemon
+    # Step 3: Start fresh daemon (lock still held — no races)
     time.sleep(1)
     from superlocalmemory.cli.daemon import ensure_daemon
     started = ensure_daemon()
+
+    # Release restart lock — daemon is now running with its own lock
+    if restart_lock_fd:
+        try:
+            restart_lock_fd.close()
+        except Exception:
+            pass
     _log(3, "Start fresh daemon", "ok" if started else "fail",
          "daemon started" if started else "failed to start — check slm doctor")
 
@@ -750,8 +773,8 @@ def cmd_remember(args: Namespace) -> None:
         except Exception:
             pass  # Fall through to pending store
 
-        # Fallback: store-first pattern (Option C — zero data loss)
-        import subprocess
+        # v3.4.13: Store to pending DB (zero data loss) — daemon processes in background.
+        # NO subprocess spawn. Daemon's background loop picks up pending memories.
         from superlocalmemory.cli.pending_store import store_pending
 
         row_id = store_pending(
@@ -759,19 +782,6 @@ def cmd_remember(args: Namespace) -> None:
             tags=args.tags or "",
         )
 
-        cmd = [sys.executable, "-m", "superlocalmemory.cli.main",
-               "remember", args.content, "--sync"]
-        if args.tags:
-            cmd.extend(["--tags", args.tags])
-        log_dir = __import__("pathlib").Path.home() / ".superlocalmemory" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_file = log_dir / "async-remember.log"
-        with open(log_file, "a") as lf:
-            subprocess.Popen(
-                cmd, stdout=subprocess.DEVNULL, stderr=lf,
-                start_new_session=True,
-            )
-
         if use_json:
             from superlocalmemory.cli.json_output import json_print
             json_print("remember", data={"queued": True, "async": True,

package/src/superlocalmemory/cli/daemon.py

@@ -288,15 +288,60 @@ def stop_daemon() -> bool:
         except Exception:
             pass
 
-    # Clean up PID/port files
+    # Clean up PID/port files + worker PID files
     _PID_FILE.unlink(missing_ok=True)
     _PORT_FILE.unlink(missing_ok=True)
+    # v3.4.13: Clean worker PID files (singleton guards)
+    for pidfile in (".embedding-worker.pid", ".reranker-worker.pid"):
+        (Path.home() / ".superlocalmemory" / pidfile).unlink(missing_ok=True)
 
+    # v3.4.13: Wait for ALL workers to actually die before returning.
+    # Without this, `slm restart` starts a new daemon before old workers exit,
+    # causing duplicate embedding_workers (1.6GB each).
     if killed:
-        logger.info("Stopped %d SLM processes", killed)
+        logger.info("Stopped %d SLM processes, waiting for exit...", killed)
+        _wait_for_workers_dead(timeout=10)
+
     return True
 
 
+def _wait_for_workers_dead(timeout: int = 10) -> None:
+    """Wait until no SLM worker processes remain alive."""
+    targets = [
+        "superlocalmemory.server.unified_daemon",
+        "superlocalmemory.core.embedding_worker",
+        "superlocalmemory.core.recall_worker",
+        "superlocalmemory.core.reranker_worker",
+    ]
+    my_pid = os.getpid()
+    deadline = time.time() + timeout
+
+    while time.time() < deadline:
+        alive = False
+        try:
+            import psutil
+            for proc in psutil.process_iter(["pid", "cmdline"]):
+                try:
+                    if proc.pid == my_pid:
+                        continue
+                    cmdline = " ".join(proc.info.get("cmdline") or [])
+                    if any(t in cmdline for t in targets):
+                        alive = True
+                        break
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+        except ImportError:
+            # No psutil — just wait a fixed time
+            time.sleep(3)
+            return
+
+        if not alive:
+            return
+        time.sleep(0.5)
+
+    logger.warning("Some SLM workers still alive after %ds timeout", timeout)
+
+
 # ---------------------------------------------------------------------------
 # Server: HTTP request handler with engine singleton
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/core/embeddings.py

@@ -62,19 +62,50 @@ class DimensionMismatchError(RuntimeError):
 # ---------------------------------------------------------------------------
 
 _EMBEDDING_LOCK_FILE = Path.home() / ".superlocalmemory" / ".embedding.lock"
-_MAX_CONCURRENT_WORKERS = int(os.environ.get("SLM_MAX_EMBEDDING_WORKERS", 2))
+_EMBEDDING_PID_FILE = Path.home() / ".superlocalmemory" / ".embedding-worker.pid"
+_MAX_CONCURRENT_WORKERS = int(os.environ.get("SLM_MAX_EMBEDDING_WORKERS", 1))
 _embedding_lock_fd: int | None = None
 
 
+def _is_embedding_worker_alive() -> bool:
+    """Check if an embedding worker PID file exists and that PID is alive.
+
+    v3.4.13: Machine-wide singleton guard. Before spawning a new worker,
+    check if one is already running. Prevents duplicate 1.6GB workers.
+    """
+    try:
+        if not _EMBEDDING_PID_FILE.exists():
+            return False
+        pid = int(_EMBEDDING_PID_FILE.read_text().strip())
+        os.kill(pid, 0)  # Signal 0 = check if alive
+        return True
+    except (ValueError, OSError, ProcessLookupError):
+        # PID file invalid or process dead — clean up stale file
+        _EMBEDDING_PID_FILE.unlink(missing_ok=True)
+        return False
+
+
+def register_embedding_worker_pid(pid: int) -> None:
+    """Write the embedding worker PID to the machine-wide PID file."""
+    _EMBEDDING_PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _EMBEDDING_PID_FILE.write_text(str(pid))
+
+
 def acquire_embedding_lock(timeout: float = 5.0) -> bool:
     """Acquire system-wide embedding worker lock.
 
-    Uses fcntl.flock on Unix. On Windows, falls back to allowing (no lock).
-    Returns True if lock acquired, False if timed out (another worker active).
+    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.
+    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 — daemon routing is primary defense
+        return True  # No file locking on Windows — PID check above is the guard
 
     import fcntl
     _EMBEDDING_LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
@@ -389,11 +420,21 @@ class EmbeddingService:
         return True
 
     def _ensure_worker(self) -> None:
-        """Spawn worker subprocess if not running."""
+        """Spawn worker subprocess if not running.
+
+        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
 
+        # v3.4.13: Check if another worker is already alive (machine-wide)
+        if _is_embedding_worker_alive():
+            logger.debug("Embedding worker already alive (PID file), skipping spawn")
+            self._available = False
+            return
+
         # V3.3.28: Check memory pressure before spawning
         if not self._check_memory_pressure():
             logger.warning("Skipping embedding worker spawn due to memory pressure")
@@ -419,8 +460,10 @@ class EmbeddingService:
                 text=True,
                 bufsize=1,
                 env=env,
-                start_new_session=True,  # Prevent terminal signals bleeding to worker
+                start_new_session=True,
             )
+            # v3.4.13: Register PID for machine-wide singleton guard
+            register_embedding_worker_pid(self._worker_proc.pid)
             logger.info("Embedding worker spawned (PID %d)", self._worker_proc.pid)
             self._worker_ready = True
         except Exception as exc:

package/src/superlocalmemory/hooks/hook_handlers.py

@@ -21,6 +21,8 @@ import subprocess
 import sys
 import tempfile
 import time
+import urllib.request
+import urllib.error
 
 # ---------------------------------------------------------------------------
 # Cross-platform temp paths
@@ -34,6 +36,30 @@ _LAST_CONSOLIDATION = os.path.join(
 )
 
 
+_DAEMON_URL = "http://127.0.0.1:8765"
+
+
+def _daemon_post(path: str, body: dict, timeout: float = 3.0) -> bool:
+    """POST to SLM daemon via stdlib urllib. Returns True on success.
+
+    v3.4.13: Hooks route through daemon HTTP instead of spawning subprocesses.
+    This eliminates the memory blast from concurrent worker spawns.
+    Uses ONLY stdlib — no httpx, no requests.
+    """
+    try:
+        data = json.dumps(body).encode("utf-8")
+        req = urllib.request.Request(
+            f"{_DAEMON_URL}{path}",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        urllib.request.urlopen(req, timeout=timeout)
+        return True
+    except Exception:
+        return False
+
+
 def handle_hook(action: str) -> None:
     """Dispatch to the appropriate hook handler. Called from main() fast path."""
     handlers = {
@@ -202,15 +228,9 @@ def _hook_checkpoint() -> None:
         if _cooldown_elapsed(lock_file, _OBSERVE_COOLDOWN, now):
             _write_timestamp(lock_file, now)
 
-            # Direct observe — SLM records the change even if Claude ignores
-            try:
-                subprocess.Popen(
-                    ["slm", "observe", f"File changed: {basename}"],
-                    stdout=subprocess.DEVNULL,
-                    stderr=subprocess.DEVNULL,
-                )
-            except Exception:
-                pass
+            # v3.4.13: Route through daemon HTTP (not subprocess) to prevent
+            # memory blast from concurrent embedding_worker spawns.
+            _daemon_post("/observe", {"content": f"File changed: {basename}"})
 
             # Log to session activity
             try:
@@ -286,33 +306,20 @@ def _hook_stop() -> None:
 
     summary = " | ".join(parts)
 
-    # --- Save to SLM ---
-    try:
-        subprocess.run(
-            ["slm", "observe", summary],
-            capture_output=True, timeout=8,
-        )
-    except Exception:
-        try:
-            subprocess.run(
-                ["slm", "remember", summary],
-                capture_output=True, timeout=8,
-            )
-        except Exception:
-            pass
-
-    # --- Post-session skill evolution trigger (best-effort) ---
-    try:
-        session_id = os.environ.get("CLAUDE_SESSION_ID", "")
-        if session_id:
-            subprocess.Popen(
-                ["slm", "evolve", "--session", session_id],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                start_new_session=True,
-            )
-    except Exception:
-        pass
+    # --- Save to SLM (v3.4.13: daemon HTTP, not subprocess) ---
+    if not _daemon_post("/observe", {"content": summary}, timeout=5.0):
+        # Fallback: try /remember if observe failed
+        _daemon_post("/remember", {"content": summary, "tags": "session-end"}, timeout=5.0)
+
+    # --- Post-session skill evolution trigger (best-effort, via tool-event) ---
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "")
+    if session_id:
+        _daemon_post("/api/v3/tool-event", {
+            "tool_name": "session_end",
+            "event_type": "session_end",
+            "session_id": session_id,
+            "output_summary": summary[:500],
+        })
 
     # --- Auto-consolidation (if >24h since last run) ---
     _maybe_consolidate()

package/src/superlocalmemory/retrieval/engine.py

@@ -187,6 +187,37 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Scene expansion: %s", exc)
 
+        # V3.4.11: Entity graph signal enhancement (post-RRF boost)
+        # Instead of competing as independent channel, entity_graph SCORES
+        # the candidates from other channels by graph proximity to query entities.
+        # Research: Microsoft GraphRAG DRIFT, Pistis-RAG cascaded architecture.
+        if (self._entity is not None
+                and "entity_graph" not in set(self._config.disabled_channels)
+                and fused):
+            try:
+                candidate_ids = [fr.fact_id for fr in fused[:100]]
+                eg_scores = self._entity.score_candidates(
+                    query, candidate_ids, profile_id,
+                )
+                if eg_scores:
+                    boosted = []
+                    for fr in fused:
+                        eg_sc = eg_scores.get(fr.fact_id, 0.0)
+                        if eg_sc > 0:
+                            eg_weight = strat.weights.get("entity_graph", 1.0)
+                            boost = 1.0 + eg_sc * eg_weight * 0.3
+                            boosted.append(FusionResult(
+                                fact_id=fr.fact_id,
+                                fused_score=fr.fused_score * boost,
+                                channel_ranks=fr.channel_ranks,
+                                channel_scores={**fr.channel_scores, "entity_graph": eg_sc},
+                            ))
+                        else:
+                            boosted.append(fr)
+                    fused = sorted(boosted, key=lambda r: r.fused_score, reverse=True)
+            except Exception as exc:
+                logger.warning("Entity graph signal enhancement: %s", exc)
+
         # 4. Load facts for rerank pool
         pool = min(len(fused), max(effective_limit * 3, 30))
         top = fused[:pool]
@@ -448,13 +479,9 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("BM25 channel: %s", exc)
 
-        if self._entity is not None and "entity_graph" not in disabled:
-            try:
-                r = self._entity.search(query, profile_id, top_k=self._config.bm25_top_k)
-                if r:
-                    out["entity_graph"] = r
-            except Exception as exc:
-                logger.warning("Entity channel: %s", exc)
+        # V3.4.12: entity_graph is now a signal enhancer (post-RRF boost),
+        # not an independent channel. Removed from channel execution to avoid
+        # running spreading activation twice. See score_candidates() in engine.recall().
 
         if self._temporal is not None and "temporal" not in disabled:
             try:

package/src/superlocalmemory/retrieval/entity_channel.py

@@ -370,6 +370,124 @@ class EntityGraphChannel:
         results.sort(key=lambda x: x[1], reverse=True)
         return results[:top_k]
 
+    def score_candidates(
+        self,
+        query: str,
+        candidate_fact_ids: list[str],
+        profile_id: str,
+    ) -> dict[str, float]:
+        """Score candidate facts by their entity-graph proximity to query entities.
+
+        V3.4.11 "Signal Enhancer" architecture: instead of returning its own
+        independent set of fact_ids (which get outranked by multi-channel facts
+        in RRF), this method scores EXISTING candidates from semantic/BM25
+        by their graph connectivity to query entities.
+
+        Research basis: Microsoft GraphRAG DRIFT Search, HippoRAG, Pistis-RAG
+        cascaded architecture. Graph signals act as post-retrieval boosters,
+        not independent retrievers. Avoids the "weakest link" phenomenon where
+        non-overlapping result sets cause rank collapse in RRF fusion.
+
+        Args:
+            query: The user's query string.
+            candidate_fact_ids: Fact IDs from semantic/BM25/other channels.
+            profile_id: User profile.
+
+        Returns:
+            Dict mapping fact_id → entity_graph score [0, 1].
+            Facts with no entity connection return 0.
+            Facts directly linked to query entities score ~1.0.
+            Facts 1-hop away score ~0.7 (decay factor).
+        """
+        if not candidate_fact_ids:
+            return {}
+
+        raw_entities = extract_query_entities(query)
+        if not raw_entities:
+            return {}
+
+        canonical_ids = self._resolve_entities(raw_entities, profile_id)
+        if not canonical_ids:
+            return {}
+
+        self._ensure_adjacency(profile_id)
+
+        # Run full spreading activation (same as search())
+        activation: dict[str, float] = defaultdict(float)
+        visited_entities: set[str] = set(canonical_ids)
+        use_cache = bool(self._entity_to_facts)
+
+        for eid in canonical_ids:
+            if use_cache:
+                for fid in self._entity_to_facts.get(eid, ()):
+                    activation[fid] = max(activation[fid], 1.0)
+            else:
+                for fact in self._db.get_facts_by_entity(eid, profile_id):
+                    activation[fact.fact_id] = max(activation[fact.fact_id], 1.0)
+
+        frontier = set(activation.keys())
+        for hop in range(1, self._max_hops):
+            hop_decay = self._decay ** hop
+            if hop_decay < self._threshold:
+                break
+            next_frontier: set[str] = set()
+            for fid in frontier:
+                if use_cache:
+                    for neighbor, edge_weight in self._adj.get(fid, ()):
+                        if self._graph_metrics:
+                            weighted = activation[fid] * self._decay * edge_weight
+                            if neighbor in self._graph_metrics:
+                                pr = self._graph_metrics[neighbor].get("pagerank_score", 0.0)
+                                weighted *= min(1.0 + pr * 2.0, 2.0)
+                        else:
+                            weighted = activation[fid] * self._decay
+                        if weighted >= self._threshold and weighted > activation.get(neighbor, 0.0):
+                            activation[neighbor] = weighted
+                            next_frontier.add(neighbor)
+
+            if use_cache:
+                for fid in frontier:
+                    for eid in self._fact_to_entities.get(fid, ()):
+                        if eid not in visited_entities:
+                            visited_entities.add(eid)
+                            for linked_fid in self._entity_to_facts.get(eid, ()):
+                                if hop_decay > activation.get(linked_fid, 0.0):
+                                    activation[linked_fid] = hop_decay
+                                    next_frontier.add(linked_fid)
+
+            frontier = next_frontier
+            if not frontier:
+                break
+
+        # Community-aware boosting (same as search)
+        if self._graph_metrics and use_cache:
+            from collections import Counter as _Counter
+            seed_communities: _Counter = _Counter()
+            for eid in canonical_ids:
+                for fid in self._entity_to_facts.get(eid, ()):
+                    m = self._graph_metrics.get(fid, {})
+                    comm = m.get("community_id")
+                    if comm is not None:
+                        seed_communities[comm] += 1
+            if seed_communities:
+                total_seeds = sum(seed_communities.values())
+                for fid in list(activation.keys()):
+                    m = self._graph_metrics.get(fid, {})
+                    fact_comm = m.get("community_id")
+                    if fact_comm is not None and fact_comm in seed_communities:
+                        boost = min(1.0 + 0.15 * (seed_communities[fact_comm] / total_seeds), 1.3)
+                        activation[fid] *= boost
+
+        # Extract scores ONLY for the candidate set, normalize to [0, 1]
+        candidate_set = set(candidate_fact_ids)
+        scored = {fid: activation.get(fid, 0.0) for fid in candidate_set}
+
+        max_score = max(scored.values()) if scored else 0
+        if max_score > 0:
+            scored = {fid: sc / max_score for fid, sc in scored.items()}
+
+        return scored
+
     def _suppress_contradictions(
         self, activation: dict[str, float], profile_id: str,
     ) -> None:

package/src/superlocalmemory/retrieval/reranker.py

@@ -27,8 +27,25 @@ import time
 import weakref
 from typing import Any
 
+from pathlib import Path
+
 from superlocalmemory.storage.models import AtomicFact
 
+_RERANKER_PID_FILE = Path.home() / ".superlocalmemory" / ".reranker-worker.pid"
+
+
+def _is_reranker_worker_alive() -> bool:
+    """Check if a reranker worker PID is already alive (machine-wide singleton)."""
+    try:
+        if not _RERANKER_PID_FILE.exists():
+            return False
+        pid = int(_RERANKER_PID_FILE.read_text().strip())
+        os.kill(pid, 0)
+        return True
+    except (ValueError, OSError, ProcessLookupError):
+        _RERANKER_PID_FILE.unlink(missing_ok=True)
+        return False
+
 # Track all live reranker instances for atexit cleanup
 _live_rerankers: set[weakref.ref] = set()
 
@@ -148,12 +165,21 @@ class CrossEncoderReranker:
     # ------------------------------------------------------------------
 
     def _ensure_worker(self) -> None:
-        """Spawn worker subprocess if not running. Non-blocking."""
+        """Spawn worker subprocess if not running. Machine-wide singleton.
+
+        v3.4.13: Checks PID file before spawning — only ONE reranker 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
         self._worker_ready = False
 
+        # v3.4.13: Machine-wide singleton guard
+        if _is_reranker_worker_alive():
+            logger.debug("Reranker worker already alive (PID file), skipping spawn")
+            return
+
         worker_module = "superlocalmemory.core.reranker_worker"
         try:
             env = {
@@ -175,6 +201,9 @@ class CrossEncoderReranker:
                 env=env,
                 start_new_session=True,
             )
+            # v3.4.13: Register PID for machine-wide singleton
+            _RERANKER_PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+            _RERANKER_PID_FILE.write_text(str(self._worker_proc.pid))
             logger.info(
                 "Reranker worker spawned (PID %d)", self._worker_proc.pid,
             )

package/src/superlocalmemory/server/unified_daemon.py

@@ -587,6 +587,9 @@ def _register_daemon_routes(application: FastAPI) -> None:
                     "score": round(r.score, 4),
                     "fact_type": getattr(r.fact.fact_type, 'value', str(r.fact.fact_type)),
                     "fact_id": r.fact.fact_id,
+                    "channel_scores": {
+                        k: round(v, 4) for k, v in r.channel_scores.items()
+                    } if r.channel_scores else {},
                 }
                 for r in response.results
             ]

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.11
+Version: 3.4.13
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -83,7 +83,7 @@ Dynamic: license-file
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf & 17+ AI tools.</em></p>
-<p align="center"><code>v3.4.4 "Neural Glass"</code> — Install once. Every session remembers the last. Automatically.</p>
+<p align="center"><code>v3.4.11</code> — Install once. Every session remembers the last. Automatically.</p>
 <p align="center"><strong>Backed by 3 peer-reviewed research papers</strong> · <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>
 
 <p align="center">
@@ -457,15 +457,20 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 - Auto-learned soft prompts injected into agent context
 - Behavioral pattern detection and outcome tracking
 
-### Skill Evolution (NEW in v3.4.10)
-- **Per-skill performance tracking** — automatically tracks which skills succeed and which fail, across sessions (zero-LLM, always on)
-- **Execution trace analysis** — mines tool usage patterns around skill invocations to determine effectiveness
-- **Skill entities in Entity Explorer** — each skill becomes a browsable entity with performance facts and evolution history
-- **Dedicated Skill Evolution dashboard tab** — overview cards, performance assertions, skill correlations
-- **Behavioral assertions for skill routing** — soft prompts recommend high-performing skills in future sessions
-- **LLM-powered skill evolution** — 3-trigger system (post-session + degradation + health check) with blind verification. **Off by default** — opt-in via `slm config set evolution.enabled true`. Supports Ollama (free, local), Anthropic API, and OpenAI API backends.
-- **ECC integration** — enhanced observation support with [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) via `slm ingest --source ecc`
-- **IDE compatibility:** Skill tracking currently works with Claude Code. The `/api/v3/tool-event` endpoint accepts events from any IDE client — adapters for other IDEs in future releases.
+### Skill Evolution
+- **Per-skill performance tracking** — tracks which skills succeed and fail across sessions (zero-LLM, always on)
+- **Evolution engine** — 3-trigger system with blind verification. Off by default — enable via `slm config set evolution.enabled true`
+- **MCP tools** — `evolve_skill`, `skill_health`, `skill_lineage` for programmatic access
+- **Lineage DAG** — visual evolution history in the dashboard
+- **CLI config** — `slm config get/set` for all evolution settings
+- **Post-session triggers** — automatic analysis on session end via Stop hook
+- **[ECC](https://github.com/affaan-m/everything-claude-code) integration** — optional enhanced observations via `slm ingest --source ecc`
+
+### Tiered Storage & Scaling
+- **4-tier lifecycle** — active, warm, cold, archived with automatic promotion/demotion
+- **Deep recall** — archived facts searchable at reduced weight
+- **Graph pruning** — automatic cleanup of orphan edges, self-loops, duplicates
+- **Fact consolidation** — clusters related facts into consolidated summaries
 
 ### Trust & Security
 - Bayesian Beta-distribution trust scoring (per-agent, per-fact)
@@ -476,9 +481,9 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 ### Infrastructure
 - 23-tab web dashboard with real-time visualization
 - 17+ IDE integrations (Claude, Cursor, Windsurf, VS Code, JetBrains, Zed, etc.)
-- 35 MCP tools + 7 MCP resources
+- 38 MCP tools + 7 MCP resources
 - Profile isolation (independent memory spaces)
-- 1400+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
+- 2,900+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
 - CPU-only — no GPU required
 - Automatic orphaned process cleanup