nexo-brain 5.6.0 → 5.6.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.6.0",
+  "version": "5.6.1",
   "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,9 @@
 
 [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 `5.6.0` is the current packaged-runtime line: default model upgrade from Opus 4.6 to **Opus 4.7** with `reasoning_effort: "max"` (the new highest tier). Auto-migration on `nexo update` silently upgrades existing users from `claude-opus-4-6*` to `claude-opus-4-7` preserving the 1M context suffix. Codex profiles are untouched.
+Version `5.6.1` is the current packaged-runtime line: two small-but-sharp fixes in the `nexo update` path. 0-byte `.db` orphans from interrupted installs are now purged from `~/.nexo/` and `~/.nexo/data/` before the pre-update backup runs, so backup validation no longer trips over empty shells. And when `heal_runtime_profiles()` migrates the `claude_code` default (e.g. Opus 4.6 → 4.7), the new `sync_claude_code_model()` helper also updates the `model` field in `~/.claude/settings.json` — the file Claude Code actually reads — so the boot model matches NEXO's recommendation on the next launch.
+
+Previously in `5.6.0`: default model upgrade from Opus 4.6 to **Opus 4.7** with `reasoning_effort: "max"` (the new highest tier). Auto-migration on `nexo update` silently upgrades existing users from `claude-opus-4-6*` to `claude-opus-4-7` preserving the 1M context suffix. Codex profiles are untouched.
 
 Previously in `5.5.5`: data-loss guardrails + automatic self-heal. The updater now refuses to capture an already-wiped `nexo.db` into a `pre-update-*` snapshot (validated `sqlite3.backup` + pre-flight wipe guard + post-migration row-count gate), and an auto-heal restores `data/nexo.db` from the newest hourly backup on the next server boot when a wipe is detected. New `nexo recover` CLI + `nexo_recover` MCP tool.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.6.0",
+  "version": "5.6.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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

@@ -836,10 +836,53 @@ def _self_heal_if_wiped() -> dict | None:
     }
 
 
+def _purge_zero_byte_db_files() -> list[Path]:
+    """Delete 0-byte .db files in NEXO_HOME and its ``data/`` subdir.
+
+    These are orphans from interrupted installs / aborted ``sqlite3.connect``
+    calls. They break backup validation by (a) masking the real DB during
+    :func:`_find_primary_db_path` selection when two ``nexo.db`` paths
+    coexist, and (b) being copied into the backup as empty shells that later
+    confuse :func:`_restore_dbs` on rollback.
+
+    Never touches SRC_DIR (the repo checkout) or the ``backups/`` tree.
+    Returns the list of removed paths for logging; failures are swallowed
+    so backup never aborts because of orphan cleanup.
+    """
+    removed: list[Path] = []
+    scan_dirs: list[Path] = []
+    if NEXO_HOME.is_dir():
+        scan_dirs.append(NEXO_HOME)
+    if DATA_DIR.is_dir() and DATA_DIR != NEXO_HOME:
+        scan_dirs.append(DATA_DIR)
+    for scan_dir in scan_dirs:
+        try:
+            candidates = [f for f in scan_dir.glob("*.db") if f.is_file()]
+        except Exception:
+            continue
+        for path in candidates:
+            try:
+                if path.stat().st_size != 0:
+                    continue
+            except Exception:
+                continue
+            try:
+                path.unlink()
+                removed.append(path)
+                _log(f"Purged zero-byte DB orphan: {path}")
+            except Exception as e:
+                _log(f"Failed to purge zero-byte DB {path}: {e}")
+    return removed
+
+
 def _backup_dbs() -> str | None:
     """Snapshot all .db files before migration. Returns backup dir or None."""
     import sqlite3
     import time as _time
+    # Drop 0-byte .db orphans first — they mask the real DB during primary
+    # path selection and turn into empty shells in the backup, breaking both
+    # validation and rollback paths. Safe no-op when there are none.
+    _purge_zero_byte_db_files()
     timestamp = _time.strftime("%Y-%m-%d-%H%M%S")
     backup_dir = NEXO_HOME / "backups" / f"pre-autoupdate-{timestamp}"
 
@@ -2271,6 +2314,32 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
             for msg in heal_messages:
                 _emit_progress(progress_fn, msg)
                 actions.append("model-heal")
+            # Claude Code reads the default model from ~/.claude/settings.json,
+            # not from client_runtime_profiles. If the heal migrated the
+            # claude_code model (e.g. Opus 4.6 → 4.7) the internal profile is
+            # now correct but Claude Code keeps booting on the old model until
+            # settings.json is also updated. Propagate conservatively: only
+            # touch settings.json when it already has a "model" field.
+            existing_cc = existing_profiles.get("claude_code") if isinstance(existing_profiles.get("claude_code"), dict) else None
+            healed_cc = healed_profiles.get("claude_code") if isinstance(healed_profiles.get("claude_code"), dict) else None
+            old_cc_model = str((existing_cc or {}).get("model") or "")
+            new_cc_model = str((healed_cc or {}).get("model") or "")
+            if new_cc_model and new_cc_model != old_cc_model:
+                try:
+                    from client_sync import sync_claude_code_model
+                    sync_result = sync_claude_code_model(new_cc_model)
+                    if sync_result.get("action") == "updated":
+                        _emit_progress(
+                            progress_fn,
+                            f"Synced Claude Code settings.json model → '{new_cc_model}'.",
+                        )
+                        actions.append("claude-settings-model")
+                    elif not sync_result.get("ok"):
+                        actions.append(
+                            f"claude-settings-model-warning:{sync_result.get('reason', 'unknown')}"
+                        )
+                except Exception as e:
+                    actions.append(f"claude-settings-model-warning:{e}")
         normalized_preferences = normalize_client_preferences(schedule_payload)
         if normalized_preferences != {
             key: schedule_payload.get(key)

package/src/client_sync.py

@@ -802,6 +802,70 @@ def _sync_claude_code_settings(path: Path, server_config: dict) -> dict:
     }
 
 
+def sync_claude_code_model(
+    model: str,
+    *,
+    user_home: str | os.PathLike[str] | None = None,
+) -> dict:
+    """Propagate the NEXO-recommended ``model`` into ``~/.claude/settings.json``.
+
+    Claude Code actually reads the default model from ``settings.json``, not
+    from NEXO's internal ``client_runtime_profiles``. When a NEXO update
+    migrates a user's recommended default (e.g. Opus 4.6 → 4.7) the internal
+    profile changes but Claude Code keeps booting on the old model until this
+    file is rewritten.
+
+    Intentionally conservative — do NOT seed a field the user never had:
+      - ``settings.json`` missing              → skip.
+      - ``settings.json`` exists but has no
+        top-level ``"model"`` key              → skip.
+      - Current value already equals ``model`` → skip (no write).
+      - JSON read/write error                  → ``ok=False``, skip.
+      - Otherwise replace the value.
+
+    Returns a small result dict: ``{ok, action, path, reason?, previous_model?, new_model?}``.
+    ``action`` is ``"updated"`` only when the file was actually rewritten.
+    """
+    result: dict = {"ok": True, "action": "skipped", "path": ""}
+    if not model:
+        result["reason"] = "empty model"
+        return result
+    home_path = Path(user_home).expanduser() if user_home else None
+    path = _claude_code_settings_path(home_path)
+    result["path"] = str(path)
+    if not path.is_file():
+        result["reason"] = "settings.json missing"
+        return result
+    try:
+        raw = path.read_text()
+        payload = json.loads(raw) if raw.strip() else {}
+    except Exception as e:
+        result["ok"] = False
+        result["reason"] = f"read failed: {e}"
+        return result
+    if not isinstance(payload, dict):
+        result["reason"] = "settings.json is not a JSON object"
+        return result
+    if "model" not in payload:
+        result["reason"] = "no model field in settings.json"
+        return result
+    current = payload.get("model")
+    if current == model:
+        result["reason"] = "already matches"
+        return result
+    payload["model"] = model
+    try:
+        _write_json_object(path, payload)
+    except Exception as e:
+        result["ok"] = False
+        result["reason"] = f"write failed: {e}"
+        return result
+    result["action"] = "updated"
+    result["previous_model"] = current
+    result["new_model"] = model
+    return result
+
+
 def sync_claude_code(
     *,
     nexo_home: str | os.PathLike[str] | None = None,