nexo-brain 7.20.12 → 7.20.14

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.12",
+  "version": "7.20.14",
   "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.20.12` is the current packaged-runtime line. Patch release over v7.20.11 — Local Context now keeps the first index pass separate from live change tracking, persists the current indexing start time, caps compact context payloads for agents, and installs the Windows host scheduler needed to keep WSL indexing alive after reboots.
+Version `7.20.14` is the current packaged-runtime line. Patch release over v7.20.13 — Brain protects Local Memory during update/recovery paths, rotates runtime backup families to the latest 5 entries, keeps first-indexing status stable, and exposes bounded indexing speed profiles for Desktop.
+
+Previously in `7.20.13`: patch release over v7.20.12 — Brain recovery now pauses all known DB writers before restoring `nexo.db`, and Doctor can repair the zero-byte/locked database state that made Desktop Local Memory show zero files.
+
+Previously in `7.20.12`: patch release over v7.20.11 — Local Context now keeps the first index pass separate from live change tracking, persists the current indexing start time, caps compact context payloads for agents, and installs the Windows host scheduler needed to keep WSL indexing alive after reboots.
 
 Previously in `7.20.11`: patch release over v7.20.10 — Local Context now starts from real system volume roots plus mounted/removable/network volumes, filters system/cache/app/product artifacts, and injects relevant local evidence automatically into heartbeat, task-open and pre-action context.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.12",
+  "version": "7.20.14",
   "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/auto_update.py

@@ -1336,7 +1336,7 @@ def _reload_launch_agents_after_bump() -> dict:
     return result
 
 
-AUTO_UPDATE_BACKUP_KEEP = 10
+AUTO_UPDATE_BACKUP_KEEP = 5
 """Maximum number of auto-update backups to keep per prefix.
 
 Both `pre-autoupdate-*/` (DB snapshots) and `runtime-tree-*/` (code mirrors)
@@ -1409,10 +1409,13 @@ def _self_heal_if_wiped() -> dict | None:
             CRITICAL_TABLES,
             HOURLY_BACKUP_MAX_AGE,
             MIN_REFERENCE_ROWS,
+            PROTECTED_TABLES,
             db_looks_wiped,
             db_row_counts,
+            find_best_hourly_backup,
             find_latest_hourly_backup,
-            kill_nexo_mcp_servers,
+            quiesce_nexo_db_writers,
+            resume_nexo_launchagents,
             safe_sqlite_backup,
             validate_backup_matches_source,
         )
@@ -1423,11 +1426,16 @@ def _self_heal_if_wiped() -> dict | None:
     primary = DATA_DIR / "nexo.db"
     if not primary.is_file():
         return None
-    if not db_looks_wiped(primary, CRITICAL_TABLES):
+    if not db_looks_wiped(primary, PROTECTED_TABLES):
         return None
-    reference = find_latest_hourly_backup(
+    reference = find_best_hourly_backup(
         paths.backups_dir(),
         max_age_seconds=HOURLY_BACKUP_MAX_AGE,
+        tables=PROTECTED_TABLES,
+    ) or find_latest_hourly_backup(
+        paths.backups_dir(),
+        max_age_seconds=HOURLY_BACKUP_MAX_AGE,
+        tables=PROTECTED_TABLES,
     )
     if reference is None:
         _log("self-heal: nexo.db looks wiped but no usable hourly backup found — skipping.")
@@ -1436,7 +1444,7 @@ def _self_heal_if_wiped() -> dict | None:
             "reason": "no_usable_hourly_backup",
             "primary_db": str(primary),
         }
-    ref_counts = db_row_counts(reference, CRITICAL_TABLES)
+    ref_counts = db_row_counts(reference, PROTECTED_TABLES)
     ref_total = sum(v for v in ref_counts.values() if isinstance(v, int))
     if ref_total < MIN_REFERENCE_ROWS:
         _log(f"self-heal: reference backup {reference.name} has {ref_total} rows, below floor {MIN_REFERENCE_ROWS}")
@@ -1467,11 +1475,29 @@ def _self_heal_if_wiped() -> dict | None:
         f"(reference={reference.name}, {ref_total} critical rows). Restoring..."
     )
 
-    # Kill any live MCP servers so they cannot overwrite the restored DB.
-    kill_report = kill_nexo_mcp_servers(dry_run=False)
-    if kill_report.get("terminated"):
-        _log(f"self-heal: terminated {kill_report['terminated']} live MCP server(s).")
-        time.sleep(0.5)
+    # Pause any live DB writers so they cannot overwrite the restored DB or
+    # keep stale handles open. Desktop installs have more writers than the MCP
+    # server: local-index, email-monitor, followup-runner, watchdog and catchup.
+    quiesce_report = quiesce_nexo_db_writers(dry_run=False)
+    stopped_launchagents = list((quiesce_report.get("launchagents") or {}).get("stopped") or [])
+    if quiesce_report.get("terminated") or stopped_launchagents:
+        _log(
+            "self-heal: quiesced DB writers "
+            f"(terminated={quiesce_report.get('terminated', 0)}, "
+            f"launchagents={len(stopped_launchagents)})."
+        )
+    if quiesce_report.get("errors"):
+        _log(f"self-heal: DB writer quiesce warnings: {quiesce_report.get('errors')}")
+
+    def _resume_quiesced() -> dict | None:
+        if not stopped_launchagents:
+            return None
+        report = resume_nexo_launchagents(stopped_launchagents)
+        if report.get("started"):
+            _log(f"self-heal: resumed {len(report['started'])} launchagent(s).")
+        if report.get("errors"):
+            _log(f"self-heal: launchagent resume warnings: {report.get('errors')}")
+        return report
 
     # Snapshot the current (wiped) state so the heal is reversible.
     pre_heal_dir = paths.backups_dir() / f"pre-heal-{time.strftime('%Y-%m-%d-%H%M%S')}"
@@ -1497,27 +1523,34 @@ def _self_heal_if_wiped() -> dict | None:
     ok, err = safe_sqlite_backup(reference, primary)
     if not ok:
         _log(f"self-heal: restore copy failed: {err}")
+        resume_report = _resume_quiesced()
         return {
             "action": "failed",
             "reason": "restore_copy_failed",
             "error": err,
             "reference": str(reference),
             "pre_heal_dir": str(pre_heal_dir),
+            "quiesce": quiesce_report,
+            "resume": resume_report,
         }
-    valid, valid_err = validate_backup_matches_source(reference, primary, CRITICAL_TABLES)
+    valid, valid_err = validate_backup_matches_source(reference, primary, PROTECTED_TABLES)
     if not valid:
         _log(f"self-heal: post-restore validation failed: {valid_err}")
+        resume_report = _resume_quiesced()
         return {
             "action": "failed",
             "reason": "validation_failed",
             "error": valid_err,
             "reference": str(reference),
             "pre_heal_dir": str(pre_heal_dir),
+            "quiesce": quiesce_report,
+            "resume": resume_report,
         }
 
-    final_counts = db_row_counts(primary, CRITICAL_TABLES)
+    final_counts = db_row_counts(primary, PROTECTED_TABLES)
     final_total = sum(v for v in final_counts.values() if isinstance(v, int))
     _log(f"self-heal: restored {final_total} critical rows from {reference.name}.")
+    resume_report = _resume_quiesced()
     try:
         SELF_HEAL_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
         SELF_HEAL_STATE_FILE.write_text(json.dumps({
@@ -1525,6 +1558,7 @@ def _self_heal_if_wiped() -> dict | None:
             "reference": str(reference),
             "critical_rows_restored": final_total,
             "pre_heal_dir": str(pre_heal_dir),
+            "quiesced_launchagents": stopped_launchagents,
         }))
     except Exception as e:
         _log(f"self-heal: state write warning: {e}")
@@ -1535,7 +1569,9 @@ def _self_heal_if_wiped() -> dict | None:
         "reference_rows": ref_total,
         "restored_rows": final_total,
         "pre_heal_dir": str(pre_heal_dir),
-        "terminated_servers": kill_report.get("terminated", 0),
+        "terminated_servers": int((quiesce_report.get("mcp") or {}).get("terminated") or 0),
+        "quiesce": quiesce_report,
+        "resume": resume_report,
     }