nexo-brain 7.37.0 → 7.37.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.37.0",
+  "version": "7.37.3",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.37.0` is the current packaged-runtime line. Minor release - transparent server self-heal: when an update lands while a Brain MCP server is already running, the resident stdio child now re-execs itself in place (same process, same live MCP connection) instead of telling the user to restart, so the updated code runs immediately with nothing visible. Fail-open (non-POSIX, re-exec error, resident service, or `NEXO_DISABLE_SELFHEAL_REEXEC` kill switch all fall back to the prior safe hard-exit), anti-loop (bounded generations + same-target guard), defers past any in-flight tool call, and a boot-time pre-serve heal. Also fixes email-monitor zombie reinjection: an already-replied email left in 'processing' after a crash is closed as terminal 'processed' and never re-sent as a duplicate reply. Builds on v7.36.0 (local index disk reclaim).
+Version `7.37.3` is the current packaged-runtime line. Patch release over v7.37.2 - release pipeline timeout hardening: the Brain publish workflow keeps the full pre-publish pytest gate, but now gives slow GitHub runners enough time to finish the suite and release readiness before public-channel publication.
+
+Previously in `7.37.2`: patch release over v7.37.1 - runtime shutdown and CI stability: session keepalive writers now stop before the shared SQLite connection closes, SQLite close is serialized under the write lock, and the full Brain test workflow has enough time to finish instead of cancelling slow-but-valid runs. The v7.37.2 tag attempt did not publish npm/GitHub release artifacts; v7.37.3 is the public line.
+
+Previously in `7.37.1`: patch release over v7.37.0 - release hardening for Desktop-bundled Brain: large existing `local-context.db` files no longer run a surprise full `VACUUM` on the first writer, `schema_abstraction` MCP tools are loaded by the essential startup set, and learning tools tolerate Desktop compatibility payloads. Builds on v7.37.0 (transparent server self-heal + email zombie reinjection guard).
 
 Previously in `7.31.9`: patch release over v7.31.8 - UI release closeout now has to prove the original reported symptom was reopened with observable evidence before claiming the release is ready.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.37.0",
+  "version": "7.37.3",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/db/_core.py

@@ -131,7 +131,8 @@ class _SerializedConnection:
             return self._conn.commit()
 
     def close(self):
-        return self._conn.close()
+        with _write_lock:
+            return self._conn.close()
 
     def __getattr__(self, name):
         return getattr(self._conn, name)

package/src/local_context/db.py

@@ -20,6 +20,8 @@ MAIN_CLEANUP_STATE_KEY = "local_context_main_tables_drained"
 # per never-converted DB (guarded by free disk) and record it here so it never
 # re-runs the expensive rewrite. See ensure_local_context_db().
 AUTO_VACUUM_CONVERTED_KEY = "auto_vacuum_converted"
+AUTO_VACUUM_MAX_SYNC_BYTES_ENV = "NEXO_LOCAL_CONTEXT_AUTO_VACUUM_MAX_SYNC_BYTES"
+DEFAULT_AUTO_VACUUM_MAX_SYNC_BYTES = 128 * 1024 * 1024
 
 LOCAL_CONTEXT_TABLES: tuple[str, ...] = (
     "local_index_roots",
@@ -472,6 +474,9 @@ def _convert_auto_vacuum_once(conn: sqlite3.Connection, db_path: Path) -> None:
             free = shutil.disk_usage(db_path.parent).free
         except OSError:
             return
+        max_sync_bytes = _auto_vacuum_max_sync_bytes()
+        if max_sync_bytes <= 0 or db_size > max_sync_bytes:
+            return
         if free <= db_size * 2:
             # Not enough scratch room — leave NONE mode, retry on a later boot.
             return
@@ -486,6 +491,16 @@ def _convert_auto_vacuum_once(conn: sqlite3.Connection, db_path: Path) -> None:
         pass
 
 
+def _auto_vacuum_max_sync_bytes() -> int:
+    value = os.environ.get(AUTO_VACUUM_MAX_SYNC_BYTES_ENV, "")
+    if value:
+        try:
+            return max(0, int(value))
+        except (TypeError, ValueError):
+            return DEFAULT_AUTO_VACUUM_MAX_SYNC_BYTES
+    return DEFAULT_AUTO_VACUUM_MAX_SYNC_BYTES
+
+
 def get_local_context_db() -> sqlite3.Connection:
     ensure_local_context_db()
     assert _CONN is not None

package/src/server.py

@@ -340,6 +340,7 @@ _ESSENTIAL_MCP_STARTUP_PLUGINS = (
     "preferences.py",
     "protocol.py",
     "recover.py",
+    "schema_abstraction.py",
     "skills.py",
     "user_state_tools.py",
     "workflow.py",
@@ -2630,12 +2631,14 @@ def nexo_learning_resolve_candidate(
 
 
 @mcp.tool
-def nexo_learning_search(query: str, category: str = "") -> str:
+def nexo_learning_search(query: str, category: str = "", limit: int = 0) -> str:
     """Search learnings by keyword. Searches title and content.
 
     Args:
         query: Search term.
         category: Filter by category (optional).
+        limit: Accepted for Desktop/client compatibility; search ranking is
+            owned by the Brain handler.
     """
     return handle_learning_search(query, category)
 
@@ -2767,13 +2770,15 @@ def nexo_learning_delete(id: int) -> str:
 
 
 @mcp.tool
-def nexo_learning_list(category: str = "", created_after: str = "", created_before: str = "") -> str:
+def nexo_learning_list(category: str = "", created_after: str = "", created_before: str = "", limit: int = 0) -> str:
     """List all learnings, grouped by category.
 
     Args:
         category: Filter by category (optional). If empty, shows all grouped.
         created_after: Filter to learnings created at or after this date/time (optional).
         created_before: Filter to learnings created at or before this date/time (optional).
+        limit: Accepted for Desktop/client compatibility; grouping is owned by
+            the Brain handler.
     """
     return handle_learning_list(category, created_after, created_before)
 

package/src/tools_sessions.py

@@ -111,7 +111,7 @@ def _safe_packet_payload(value, *, _depth: int = 0):
         return [_safe_packet_payload(item, _depth=_depth + 1) for item in list(value)[:100]]
     return _safe_packet_text(value)
 
-_keepalive_threads: dict[str, threading.Event] = {}  # sid → stop_event
+_keepalive_threads: dict[str, tuple[threading.Event, threading.Thread]] = {}  # sid -> (stop_event, thread)
 
 
 def _env_flag(name: str, default: bool = False) -> bool:
@@ -235,16 +235,34 @@ def _start_keepalive(sid: str) -> None:
     """Start a keepalive thread for the given session."""
     _stop_keepalive(sid)  # clean up any leftover
     stop_event = threading.Event()
-    _keepalive_threads[sid] = stop_event
     t = threading.Thread(target=_keepalive_loop, args=(sid, stop_event), daemon=True)
+    _keepalive_threads[sid] = (stop_event, t)
     t.start()
 
 
-def _stop_keepalive(sid: str) -> None:
+def _stop_keepalive(sid: str, join_timeout: float = 1.0) -> None:
     """Signal the keepalive thread for the given session to stop."""
-    stop_event = _keepalive_threads.pop(sid, None)
-    if stop_event is not None:
+    entry = _keepalive_threads.pop(sid, None)
+    if entry is None:
+        return
+    stop_event, thread = entry
+    stop_event.set()
+    if thread is not threading.current_thread():
+        thread.join(timeout=max(0.0, join_timeout))
+
+
+def _stop_all_keepalives(join_timeout: float = 1.0) -> None:
+    """Signal and briefly join all keepalive threads before DB shutdown."""
+    entries = list(_keepalive_threads.values())
+    _keepalive_threads.clear()
+    for stop_event, _thread in entries:
         stop_event.set()
+    deadline = time.monotonic() + max(0.0, join_timeout)
+    for _stop_event, thread in entries:
+        if thread is threading.current_thread():
+            continue
+        remaining = max(0.0, deadline - time.monotonic())
+        thread.join(timeout=remaining)
 
 
 def _generate_sid() -> str:

package/tool-enforcement-map.json

@@ -3283,6 +3283,19 @@
       },
       "triggers_after": []
     },
+    "nexo_memory_forget": {
+      "description": "Selective forget for revoked secrets or reversible fact correction",
+      "category": "memory",
+      "source": "server",
+      "requires": [],
+      "provides": [],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_memory_health": {
       "description": "Report Memory Observations v2 health and table status",
       "category": "memory",