nexo-brain 2.6.16 → 2.6.17

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.16",
+  "version": "2.6.17",
   "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

@@ -38,11 +38,13 @@ That means NEXO now manages not only the shared runtime and MCP wiring, but also
 - For Codex specifically, `nexo chat` and Codex headless automation inject the current bootstrap explicitly, so Codex starts as NEXO even when plain global Codex startup is inconsistent about global instructions.
 - Deep Sleep now reads both Claude Code and Codex transcript stores, so overnight analysis still works even when the user spends the day in Codex.
 
-Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, and `2.6.16` pushes the system further in three directions:
+Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, `2.6.16` pushes the system further in three directions, and `2.6.17` finishes the annoying last-mile migration bugs for real existing installs:
 
 - Codex now gets managed global bootstrap/model sync in `~/.codex/config.toml`, so sessions opened outside `nexo chat` are much less likely to start as plain Codex.
 - Retrieval is smarter by default: HyDE and spreading activation now auto-enable when the query shape benefits, while exact lookups remain conservative.
 - Deep Sleep now blends recent context with older context over a 60-day horizon, and memory decay now tracks per-memory `stability` and `difficulty` instead of relying only on global decay constants.
+- Existing installs that already had NEXO connected to Codex now backfill that client state automatically during update/sync, so the managed Codex bootstrap actually lands without manual cleanup.
+- Bootstrap docs now fall back to the operator name `NEXO` when local metadata is blank, avoiding broken headings in `CLAUDE.md` and `AGENTS.md`.
 
 ### Client Capability Matrix
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.16",
+  "version": "2.6.17",
   "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

@@ -1434,10 +1434,19 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
 
         schedule_path = dest / "config" / "schedule.json"
         schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
+        normalized_preferences = normalize_client_preferences(schedule_payload)
+        if normalized_preferences != {
+            key: schedule_payload.get(key)
+            for key in normalized_preferences
+        }:
+            merged_schedule = dict(schedule_payload)
+            merged_schedule.update(normalized_preferences)
+            schedule_path.parent.mkdir(parents=True, exist_ok=True)
+            schedule_path.write_text(json.dumps(merged_schedule, indent=2, ensure_ascii=False) + "\n")
         client_sync_result = sync_all_clients(
             nexo_home=dest,
             runtime_root=dest,
-            preferences=normalize_client_preferences(schedule_payload),
+            preferences=normalized_preferences,
         )
         if client_sync_result.get("ok"):
             actions.append("client-sync")

package/src/bootstrap_docs.py

@@ -73,7 +73,9 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     version_file = nexo_home / "version.json"
     if version_file.is_file():
         try:
-            return str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            candidate = str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            if candidate:
+                return candidate
         except Exception:
             pass
     return "NEXO"

package/src/client_preferences.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import shutil
 import sys
+import tomllib
 from pathlib import Path
 
 from runtime_power import load_schedule_config, save_schedule_config
@@ -51,6 +52,14 @@ def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
 
 
+def _codex_config_path(home: Path) -> Path:
+    return home / ".codex" / "config.toml"
+
+
+def _codex_bootstrap_path(home: Path) -> Path:
+    return home / ".codex" / "AGENTS.md"
+
+
 def _coerce_bool(value, default: bool) -> bool:
     if isinstance(value, bool):
         return value
@@ -127,6 +136,56 @@ def normalize_interactive_clients(value) -> dict[str, bool]:
     return normalized
 
 
+def _codex_artifacts_suggest_nexo_management(home: Path) -> bool:
+    bootstrap_path = _codex_bootstrap_path(home)
+    if bootstrap_path.is_file():
+        try:
+            bootstrap_text = bootstrap_path.read_text()
+        except Exception:
+            bootstrap_text = ""
+        if (
+            "nexo-codex-agents-version:" in bootstrap_text
+            or "NEXO Shared Brain for Codex" in bootstrap_text
+            or "<!-- nexo:core:start -->" in bootstrap_text
+        ):
+            return True
+
+    config_path = _codex_config_path(home)
+    if not config_path.is_file():
+        return False
+
+    try:
+        payload = tomllib.loads(config_path.read_text())
+    except Exception:
+        try:
+            raw_text = config_path.read_text()
+        except Exception:
+            return False
+        return "[mcp_servers.nexo]" in raw_text or "[nexo.codex]" in raw_text
+
+    if not isinstance(payload, dict):
+        return False
+    mcp_servers = payload.get("mcp_servers")
+    if isinstance(mcp_servers, dict) and "nexo" in mcp_servers:
+        return True
+    nexo_table = payload.get("nexo")
+    if isinstance(nexo_table, dict) and "codex" in nexo_table:
+        return True
+    return False
+
+
+def _backfill_interactive_clients(
+    interactive_clients: dict[str, bool],
+    *,
+    user_home: str | os.PathLike[str] | None = None,
+) -> dict[str, bool]:
+    normalized = dict(interactive_clients)
+    home = Path(user_home).expanduser() if user_home else _user_home()
+    if not normalized.get(CLIENT_CODEX, False) and _codex_artifacts_suggest_nexo_management(home):
+        normalized[CLIENT_CODEX] = True
+    return normalized
+
+
 def normalize_default_terminal_client(value, interactive_clients: dict[str, bool] | None = None) -> str:
     interactive_clients = normalize_interactive_clients(interactive_clients or {})
     candidate = normalize_client_key(value)
@@ -210,9 +269,16 @@ def normalize_client_runtime_profiles(value) -> dict[str, dict[str, str]]:
     return normalized
 
 
-def normalize_client_preferences(schedule: dict | None = None) -> dict:
+def normalize_client_preferences(
+    schedule: dict | None = None,
+    *,
+    user_home: str | os.PathLike[str] | None = None,
+) -> dict:
     schedule = dict(schedule or {})
-    interactive_clients = normalize_interactive_clients(schedule.get("interactive_clients"))
+    interactive_clients = _backfill_interactive_clients(
+        normalize_interactive_clients(schedule.get("interactive_clients")),
+        user_home=user_home,
+    )
     automation_enabled = normalize_automation_enabled(schedule.get("automation_enabled"))
     default_terminal_client = normalize_default_terminal_client(
         schedule.get("default_terminal_client"),

package/src/client_sync.py

@@ -80,10 +80,12 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     version_file = nexo_home / "version.json"
     if version_file.is_file():
         try:
-            return str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            candidate = str(json.loads(version_file.read_text()).get("operator_name", "")).strip()
+            if candidate:
+                return candidate
         except Exception:
             pass
-    return ""
+    return "NEXO"
 
 
 def _resolve_runtime_root(nexo_home: Path, runtime_root: str | os.PathLike[str] | None = None) -> Path:

package/src/plugins/update.py

@@ -592,11 +592,20 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
 
             schedule_path = NEXO_HOME / "config" / "schedule.json"
             schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
+            normalized_preferences = normalize_client_preferences(schedule_payload)
+            if normalized_preferences != {
+                key: schedule_payload.get(key)
+                for key in normalized_preferences
+            }:
+                merged_schedule = dict(schedule_payload)
+                merged_schedule.update(normalized_preferences)
+                schedule_path.parent.mkdir(parents=True, exist_ok=True)
+                schedule_path.write_text(json.dumps(merged_schedule, indent=2, ensure_ascii=False) + "\n")
             client_sync_result = sync_all_clients(
                 nexo_home=NEXO_HOME,
                 runtime_root=SRC_DIR,
                 operator_name=os.environ.get("NEXO_NAME", ""),
-                preferences=normalize_client_preferences(schedule_payload),
+                preferences=normalized_preferences,
             )
             if client_sync_result.get("ok"):
                 steps_done.append("client-sync")

package/src/scripts/nexo-update.sh

@@ -266,7 +266,13 @@ sys.path.insert(0, os.environ["NEXO_CODE"])
 from client_preferences import normalize_client_preferences
 
 schedule_file = Path(os.environ["NEXO_HOME"]) / "config" / "schedule.json"
-prefs = normalize_client_preferences(json.loads(schedule_file.read_text())) if schedule_file.exists() else normalize_client_preferences({})
+schedule_payload = json.loads(schedule_file.read_text()) if schedule_file.exists() else {}
+prefs = normalize_client_preferences(schedule_payload)
+if prefs != {key: schedule_payload.get(key) for key in prefs}:
+    merged = dict(schedule_payload)
+    merged.update(prefs)
+    schedule_file.parent.mkdir(parents=True, exist_ok=True)
+    schedule_file.write_text(json.dumps(merged, indent=2, ensure_ascii=False) + "\n")
 enabled = [key for key, value in prefs.get("interactive_clients", {}).items() if value]
 if prefs.get("automation_enabled", True):
     backend = prefs.get("automation_backend")