superlocalmemory 3.4.61 → 3.4.63

package/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable changes to SuperLocalMemory V3 will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.4.63] - 2026-05-31 — Dashboard search: fix async blocking + fast mode
+
+Fixes "signal is aborted without reason" in dashboard search (second root cause,
+different from v3.4.61's WorkerPool fix).
+
+### Root Cause
+`engine.recall()` is a synchronous blocking Python call (~2-10s). Calling it
+directly inside an `async` FastAPI route blocks the ASGI event loop for the
+full duration. Chrome detects a stalled HTTP connection (no response headers
+being sent) and fires `controller.abort()` with no reason — producing the
+"signal is aborted without reason" browser error, regardless of fetch timeout.
+
+### Fix
+1. `await loop.run_in_executor(None, lambda: engine.recall(...))` — offloads
+   the blocking call to a thread pool. Event loop stays alive to send HTTP
+   keepalive frames, preventing Chrome from aborting the connection.
+2. `fast=True` — skips spreading_activation + Hopfield channels, reducing
+   recall from 9.5s to <2s. These channels add precision for MCP/session_init
+   but are unnecessary for dashboard search results.
+
+### Result
+Dashboard search: 919ms cold, 1.7s warm. Zero browser aborts.
+Works immediately after `slm restart` — no wait needed.
+
+### Changed
+- `server/routes/memories.py`: `search_memories` uses `run_in_executor` + `fast=True`
+
+---
+
+## [3.4.62] - 2026-05-31 — Recall engine pre-warm on startup
+
+Adds a `recall-warmup` background thread that fires one full 6-channel recall
+immediately after daemon startup. This loads the graph_edges table (~100 MB,
+347K rows) into SQLite's page cache before the first user query arrives.
+
+Without this, cold first query = 15-24s (reading graph_edges from disk).
+After this warmup, all queries hit warm cache at <2s — for both MCP and dashboard.
+Warmup is non-blocking (daemon stays available), fires after embedding warm.
+
+### Changed
+- `server/unified_daemon.py`: `_warmup_recall()` thread fires after `_warmup_embedder()`
+
+---
+
 ## [3.4.61] - 2026-05-31 — Dashboard search fix (in-process engine)
 
 **Fixes dashboard search always timing out** with "signal is aborted without reason".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.61",
+  "version": "3.4.63",
   "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.61"
+version = "3.4.63"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/__init__.py

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

package/src/superlocalmemory/server/routes/memories.py

@@ -412,12 +412,23 @@ async def search_memories(request: Request, body: SearchRequest):
     from superlocalmemory.core.recall_gate import begin_recall, end_recall
     begin_recall()
     try:
-        # Use the daemon engine directly — already loaded, shares warm cache
+        # Use the daemon engine directly — already loaded, shares warm cache.
+        # v3.4.63: engine.recall() is synchronous/blocking (~2-10s). Calling it
+        # directly in an async route blocks the ASGI event loop — Chrome detects
+        # a stalled connection and aborts with "signal is aborted without reason"
+        # before the response arrives. Fix: run in a thread-pool executor so the
+        # event loop stays alive to send keepalive frames. Also fast=True skips
+        # spreading_activation + Hopfield (saves ~7s on cold graph traversal).
+        import asyncio
+        import time as _time
         engine = _get_engine(request)
         if engine is not None:
-            import time as _time
+            loop = asyncio.get_event_loop()
             t0 = _time.monotonic()
-            response = engine.recall(body.query, limit=body.limit)
+            response = await loop.run_in_executor(
+                None,
+                lambda: engine.recall(body.query, limit=body.limit, fast=True),
+            )
             elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
             results = []
             for r in response.results[: body.limit]:

package/src/superlocalmemory/server/unified_daemon.py

@@ -574,7 +574,37 @@ async def lifespan(application: FastAPI):
                     logger.info("Embedding worker pre-warmed (model resident, keep_alive=-1)")
             except Exception as exc:
                 logger.warning("Embedding warmup failed: %s", exc)
+
+        def _warmup_recall():
+            """v3.4.62: Fire a full 6-channel recall after embedding warms up.
+
+            Loads the graph_edges table (347K rows, ~100 MB) into the SQLite
+            page cache. Without this, the first user query takes 15-24s because
+            it reads graph_edges from disk. After this warmup completes, all
+            subsequent queries hit the warm page cache at <2s.
+
+            Runs after embedding warm (embed first so recall can use it).
+            Named 'recall-warmup' so it appears clearly in thread dumps.
+            """
+            import time as _t
+            # Wait for embedder to finish first (embed is needed by semantic channel)
+            for _ in range(60):
+                if _embedding_warm:
+                    break
+                _t.sleep(0.5)
+            try:
+                t0 = _t.monotonic()
+                response = engine.recall("memory recall performance", limit=1)
+                elapsed = round((_t.monotonic() - t0) * 1000)
+                logger.info(
+                    "Recall engine pre-warmed in %dms — graph page cache now hot "
+                    "(results=%d)", elapsed, len(response.results),
+                )
+            except Exception as exc:
+                logger.warning("Recall warmup failed (non-fatal): %s", exc)
+
         threading.Thread(target=_warmup_embedder, daemon=True, name="embed-warmup").start()
+        threading.Thread(target=_warmup_recall, daemon=True, name="recall-warmup").start()
 
         # v3.4.37: QueueConsumer uses daemon's engine directly via adapter.
         # Previously routed through WorkerPool → recall_worker subprocess,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.61
+Version: 3.4.63
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later