nexo-brain 7.23.11 → 7.23.12

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.23.11",
+  "version": "7.23.12",
   "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,11 +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.23.11` is the current packaged-runtime line. Patch over v7.23.10 - older installed runtimes can update safely even when `cognitive_paths.py` has not been synced yet.
+Version `7.23.12` is the current packaged-runtime line. Patch over v7.23.11 - protected database recovery now repairs degraded Brain tables from backup without rolling back newer rows.
 
-Previously in `7.23.6`: patch over v7.23.5 - `nexo update` clears safe legacy `cognitive.db` shadows and keeps superseded archives under runtime backup retention.
+Previously in `7.23.11`: patch over v7.23.10 - older installed runtimes can update safely even when `cognitive_paths.py` has not been synced yet.
 
-Previously in `7.23.5`: patch over v7.23.4 - `nexo update` keeps external CLI maintenance summary copy in English.
+Previously in `7.23.6`: patch over v7.23.5 - `nexo update` clears safe legacy `cognitive.db` shadows and keeps superseded archives under runtime backup retention.
 
 Previously in `7.23.3`: patch over v7.23.2 - Followup runner skips DONE terminal statuses so already-finished followups do not re-enter executable batches.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.23.11",
+  "version": "7.23.12",
   "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_guard.py

@@ -29,7 +29,7 @@ auto_update.py):
     diff_row_counts(current, reference, tables) -> WipeReport
     safe_sqlite_backup(source, dest) -> tuple[bool, str | None]
     validate_backup_matches_source(source, dest, tables) -> tuple[bool, str | None]
-    restore_tables_from_backup(source, target, tables) -> dict
+    restore_tables_from_backup(source, target, tables, mode) -> dict
     kill_nexo_mcp_servers(dry_run) -> dict
     quiesce_nexo_db_writers(dry_run) -> dict
     resume_nexo_launchagents(labels, dry_run) -> dict
@@ -501,23 +501,42 @@ def _quote_identifier(identifier: str) -> str:
     return '"' + identifier.replace('"', '""') + '"'
 
 
+def _quote_sql_name(identifier: str) -> str:
+    return '"' + identifier.replace('"', '""') + '"'
+
+
+def _table_columns(conn: sqlite3.Connection, schema: str, table: str) -> list[str]:
+    if schema not in {"main", "backup_db"}:
+        raise ValueError(f"refusing unsafe schema identifier: {schema!r}")
+    quoted = _quote_identifier(table)
+    rows = conn.execute(f"PRAGMA {schema}.table_info({quoted})").fetchall()
+    return [str(row[1]) for row in rows]
+
+
 def restore_tables_from_backup(
     source: str | Path,
     target: str | Path,
     tables: tuple[str, ...] = LOCAL_CONTEXT_TABLES,
+    *,
+    mode: str = "replace",
 ) -> dict:
-    """Replace selected tables in ``target`` with the copy from ``source``.
+    """Restore selected tables in ``target`` from ``source``.
 
-    This is intentionally table-scoped. It lets Doctor/repair recover days of
-    local indexing from a backup without rolling back newer conversations,
-    credentials, followups, or other Brain state created after that backup.
+    ``mode="replace"`` keeps the historical behavior: target rows are deleted
+    and replaced by the backup table. ``mode="merge_missing"`` preserves target
+    rows and inserts missing rows from the backup with ``INSERT OR IGNORE``.
+    This is intentionally table-scoped so repair can recover data without
+    rolling back unrelated Brain state created after the backup.
     """
+    if mode not in {"replace", "merge_missing"}:
+        raise ValueError(f"unsupported restore mode: {mode!r}")
     src = Path(source)
     dst = Path(target)
     result: dict = {
         "ok": False,
         "source": str(src),
         "target": str(dst),
+        "mode": mode,
         "tables": {},
         "errors": [],
     }
@@ -553,13 +572,29 @@ def restore_tables_from_backup(
                     continue
                 conn.execute(create_sql)
             before = _table_count(conn, table) or 0
-            conn.execute(f"DELETE FROM main.{quoted}")
-            conn.execute(f"INSERT INTO main.{quoted} SELECT * FROM backup_db.{quoted}")
+            if mode == "replace":
+                conn.execute(f"DELETE FROM main.{quoted}")
+                conn.execute(f"INSERT INTO main.{quoted} SELECT * FROM backup_db.{quoted}")
+                status = "restored"
+            else:
+                target_columns = _table_columns(conn, "main", table)
+                source_columns = set(_table_columns(conn, "backup_db", table))
+                common_columns = [column for column in target_columns if column in source_columns]
+                if not common_columns:
+                    result["tables"][table] = {"status": "no_common_columns", "before": int(before)}
+                    continue
+                column_sql = ", ".join(_quote_sql_name(column) for column in common_columns)
+                conn.execute(
+                    f"INSERT OR IGNORE INTO main.{quoted} ({column_sql}) "
+                    f"SELECT {column_sql} FROM backup_db.{quoted}"
+                )
+                status = "merged"
             after = _table_count(conn, table) or 0
             result["tables"][table] = {
-                "status": "restored",
+                "status": status,
                 "before": int(before),
                 "after": int(after),
+                "restored": max(int(after) - int(before), 0),
             }
         conn.commit()
         result["ok"] = not result["errors"]

package/src/doctor/providers/boot.py

@@ -202,21 +202,26 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
         evidence.extend(["Local memory regression:", *local_regression.summary_lines()])
 
     if fix and recoverable_regression:
-        report = restore_tables_from_backup(reference, db_path)
+        report = restore_tables_from_backup(
+            reference,
+            db_path,
+            tables=PROTECTED_TABLES,
+            mode="merge_missing",
+        )
         if report.get("ok"):
             restored = {
                 table: payload
                 for table, payload in (report.get("tables") or {}).items()
-                if isinstance(payload, dict) and payload.get("status") == "restored"
+                if isinstance(payload, dict) and payload.get("status") in {"restored", "merged"}
             }
-            restored_rows = sum(int(payload.get("after") or 0) for payload in restored.values())
+            restored_rows = sum(int(payload.get("restored") or 0) for payload in restored.values())
             return DoctorCheck(
                 id="boot.db_integrity",
                 tier="boot",
                 status="healthy",
                 severity="info",
-                summary=f"Local memory restored from backup ({restored_rows} protected rows)",
-                evidence=evidence + [f"Restored local-memory tables: {len(restored)}"],
+                summary=f"Database protected tables restored from backup ({restored_rows} rows recovered)",
+                evidence=evidence + [f"Restored protected tables: {len(restored)}"],
                 fixed=True,
             )
         return DoctorCheck(
@@ -224,7 +229,7 @@ def check_db_integrity(fix: bool = False) -> DoctorCheck:
             tier="boot",
             status="critical",
             severity="error",
-            summary="Local memory repair failed",
+            summary="Database protected-table repair failed",
             evidence=evidence + [f"Restore errors: {report.get('errors') or []}"],
             repair_plan=["Close NEXO Desktop and run nexo doctor --tier boot --plane database_real --fix"],
         )