superlocalmemory 3.4.62 → 3.4.64

package/CHANGELOG.md

@@ -5,6 +5,58 @@ 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.64] - 2026-05-31 — Fix recall/trace endpoint (Recall Lab search)
+
+The dashboard "Search memories" button (Recall Lab) calls `POST /api/v3/recall/trace`,
+NOT `POST /api/search`. v3.4.63 fixed the wrong endpoint. This is the real fix.
+
+### Root Cause
+`recall_trace()` called `WorkerPool.shared().recall()` — subprocess worker pool
+that blocks the ASGI event loop and crashes (`Worker died`) after ~17s. The
+15s global fetch timeout in core.js fired first, aborting with "signal is aborted
+without reason".
+
+### Fix
+Same pattern as v3.4.63: `run_in_executor` + daemon engine + `fast=True`.
+Synthesis removed (was using the crashed subprocess anyway).
+
+### Result
+recall/trace: 7.2s cold, 1.1s warm. Zero browser aborts. No more "Worker died".
+
+### Changed
+- `server/routes/v3_api.py`: `recall_trace` uses `run_in_executor` + daemon engine
+
+---
+
+## [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.62",
+  "version": "3.4.64",
   "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.62"
+version = "3.4.64"
 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.62"
+__version__ = "3.4.64"
 
 _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/routes/v3_api.py

@@ -514,45 +514,60 @@ async def set_provider(request: Request):
 
 @router.post("/recall/trace")
 async def recall_trace(request: Request):
-    """Recall with per-channel score breakdown."""
+    """Recall with per-channel score breakdown.
+
+    v3.4.64: Replaced WorkerPool.shared() (subprocess, blocks event loop,
+    worker crashes after ~15s) with daemon engine via run_in_executor.
+    Same fix as POST /api/search in v3.4.63.
+    """
+    import asyncio
+    import time as _time
     try:
         body = await request.json()
         query = body.get("query", "")
         limit = body.get("limit", 10)
 
-        from superlocalmemory.core.worker_pool import WorkerPool
-        pool = WorkerPool.shared()
-        result = pool.recall(query, limit=limit)
-
-        if not result.get("ok"):
-            return JSONResponse(
-                {"error": result.get("error", "Recall failed")},
-                status_code=503,
-            )
-
-        # Optional: synthesize answer from results (Mode B/C only)
-        synthesis = ""
-        if body.get("synthesize") and result.get("results"):
-            try:
-                syn_result = pool.synthesize(query, result["results"][:5])
-                synthesis = syn_result.get("synthesis", "") if syn_result.get("ok") else ""
-            except Exception:
-                pass
+        # Use daemon engine — already loaded, shares warm page cache.
+        # run_in_executor keeps event loop alive so browser doesn't abort.
+        from .helpers import get_engine_lazy
+        engine = get_engine_lazy(request.app.state)
+        if engine is None:
+            return JSONResponse({"error": "Engine not initialised"}, status_code=503)
+
+        loop = asyncio.get_event_loop()
+        t0 = _time.monotonic()
+        response = await loop.run_in_executor(
+            None,
+            lambda: engine.recall(query, limit=limit, fast=True),
+        )
+        elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
+
+        results = []
+        for r in response.results[: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", ""),
+            })
 
         # Record learning signals (non-blocking, non-critical)
         try:
-            _record_learning_signals(query, result.get("results", []))
+            _record_learning_signals(query, results)
         except Exception as _sig_exc:
             import logging as _log
             _log.getLogger(__name__).warning("Learning signal error: %s", _sig_exc)
 
         return {
             "query": query,
-            "query_type": result.get("query_type", "unknown"),
-            "result_count": result.get("result_count", 0),
-            "retrieval_time_ms": result.get("retrieval_time_ms", 0),
-            "results": result.get("results", []),
-            "synthesis": synthesis,
+            "query_type": getattr(response, "query_type", "semantic"),
+            "result_count": len(results),
+            "retrieval_time_ms": elapsed_ms,
+            "results": results,
+            "synthesis": "",
         }
     except Exception as e:
         return JSONResponse({"error": str(e)}, status_code=500)

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

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