superlocalmemory 3.4.60 → 3.4.62

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.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".
+
+### Root Cause
+`POST /api/search` (used by the SLM dashboard memories pane) called
+`WorkerPool.shared()` — the legacy subprocess-based worker pool from v3.4.32
+(pre-unified-daemon). This spawned a fresh Python subprocess and loaded the full
+SLM engine cold on **every single search request**, taking 15–20s. The browser's
+AbortController always fired before the response arrived.
+
+The `/recall` HTTP endpoint (used by MCP `session_init`) uses the daemon engine
+directly and is warm at <1s. The dashboard used a completely different code path.
+
+### Fix
+`search_memories` now calls `_get_engine(request).recall()` — the daemon's own
+in-process engine that is already loaded and shares the warm SQLite page cache.
+Falls back to direct LIKE text search if engine is unavailable during startup.
+
+### Result
+Dashboard search: **<1s warm** (was >15s → browser abort).
+GitHub sync failure shown in sidebar is a separate backup connectivity issue,
+unrelated to search.
+
+### Changed
+- `server/routes/memories.py`: `search_memories` uses daemon engine, not WorkerPool
+
+---
+
 ## [3.4.60] - 2026-05-31 — Daemon OpenMP Crash Hotfix
 
 **Hotfix for v3.4.59.** Forces `OMP_NUM_THREADS=1` and `KMP_DUPLICATE_LIB_OK=TRUE`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.60",
+  "version": "3.4.62",
   "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.60"
+version = "3.4.62"
 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.60"
+__version__ = "3.4.62"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

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

@@ -398,27 +398,47 @@ async def get_graph(
 
 @router.post("/api/search")
 async def search_memories(request: Request, body: SearchRequest):
-    """Semantic search via subprocess worker pool (memory-isolated).
+    """Semantic search using the daemon's in-process engine.
 
-    v3.4.32: marks recall in-flight so the pending materializer yields.
+    v3.4.61: Replaced WorkerPool.shared() (subprocess-based, cold-starts on
+    every request, always >15s) with the daemon's own engine that is already
+    loaded and warm. WorkerPool.shared() was legacy from v3.4.32 before the
+    unified daemon architecture. Using the daemon engine matches what the /recall
+    HTTP endpoint does and shares its warm SQLite page cache, bringing dashboard
+    search from >15s timeout to <1s warm.
+
+    Falls back to direct DB LIKE search if engine is unavailable.
     """
     from superlocalmemory.core.recall_gate import begin_recall, end_recall
     begin_recall()
     try:
-        from superlocalmemory.core.worker_pool import WorkerPool
-        pool = WorkerPool.shared()
-        result = pool.recall(body.query, limit=body.limit)
-
-        if result.get("ok"):
+        # Use the daemon engine directly — already loaded, shares warm cache
+        engine = _get_engine(request)
+        if engine is not None:
+            import time as _time
+            t0 = _time.monotonic()
+            response = engine.recall(body.query, limit=body.limit)
+            elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
+            results = []
+            for r in response.results[: body.limit]:
+                results.append({
+                    "fact_id": r.fact.fact_id,
+                    "memory_id": getattr(r.fact, "memory_id", ""),
+                    "content": r.fact.content[:300],
+                    "score": round(r.score, 4),
+                    "confidence": round(getattr(r, "confidence", 0.0), 4),
+                    "channel_scores": getattr(r, "channel_scores", {}),
+                    "created_at": getattr(r.fact, "created_at", ""),
+                })
             return {
                 "query": body.query,
-                "results": result.get("results", []),
-                "total": result.get("result_count", 0),
-                "query_type": result.get("query_type", "unknown"),
-                "retrieval_time_ms": result.get("retrieval_time_ms", 0),
+                "results": results,
+                "total": len(results),
+                "query_type": getattr(response, "query_type", "semantic"),
+                "retrieval_time_ms": elapsed_ms,
             }
 
-        # Fallback: direct DB text search (no engine needed)
+        # Fallback: direct DB text search (engine not yet initialised)
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()

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.60
+Version: 3.4.62
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later