nexo-brain 7.30.23 → 7.30.24

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.23",
+  "version": "7.30.24",
   "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 `7.30.23` is the current packaged-runtime line. Patch release over v7.30.22 - Brain now ships Opportunity Orchestrator Phase 1 for evidence-backed proactive preparation, read-only dry-run reports, bounded proposal queues, and feedback/suppression controls.
+Version `7.30.24` is the current packaged-runtime line. Patch release over v7.30.23 - client sync now stages and verifies managed MCP providers before writing Brain-owned default MCP entries into Claude, Codex, or Desktop configs.
+
+Previously in `7.30.23`: patch release over v7.30.22 - Brain ships Opportunity Orchestrator Phase 1 for evidence-backed proactive preparation, read-only dry-run reports, bounded proposal queues, and feedback/suppression controls.
 
 Previously in `7.30.20`: patch release over v7.30.19 - packaged installs now copy the `product_knowledge` package into the installed runtime so `nexo update` can import the new product knowledge tools.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.23",
+  "version": "7.30.24",
   "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/client_sync.py

@@ -24,11 +24,21 @@ from bootstrap_docs import sync_client_bootstrap
 from runtime_home import resolve_nexo_home
 
 try:
-    from managed_mcp import build_managed_server_entries, merge_json_mcp_servers, merge_toml_mcp_servers
+    from managed_mcp import (
+        build_managed_server_entries,
+        merge_json_mcp_servers,
+        merge_toml_mcp_servers,
+        reconcile_managed_mcp,
+        remove_json_nexo_managed_mcp_servers,
+        remove_toml_nexo_managed_mcp_servers,
+    )
 except Exception:
     build_managed_server_entries = None
     merge_json_mcp_servers = None
     merge_toml_mcp_servers = None
+    reconcile_managed_mcp = None
+    remove_json_nexo_managed_mcp_servers = None
+    remove_toml_nexo_managed_mcp_servers = None
 
 try:
     from client_preferences import (
@@ -842,7 +852,7 @@ def build_server_config(
 def _managed_mcp_entries_for(client: str, server_config: dict) -> dict:
     if str(os.environ.get("NEXO_MANAGED_MCP_DISABLE", "")).strip().lower() in {"1", "true", "yes", "on"}:
         return {}
-    if not build_managed_server_entries:
+    if not build_managed_server_entries or not reconcile_managed_mcp:
         return {}
     env = server_config.get("env") if isinstance(server_config.get("env"), dict) else {}
     nexo_home = str(env.get("NEXO_HOME") or "").strip()
@@ -855,16 +865,51 @@ def _managed_mcp_entries_for(client: str, server_config: dict) -> dict:
         or ""
     ).strip()
     try:
-        return build_managed_server_entries(
+        plan = reconcile_managed_mcp(
+            nexo_home=nexo_home,
+            runtime_root=runtime_root or None,
+            clients=[client],
+            apply=True,
+            platform=target_platform or None,
+        )
+        providers = plan.get("providers") if isinstance(plan.get("providers"), dict) else {}
+        if not plan.get("ok") or not providers:
+            return {}
+        entries = build_managed_server_entries(
             client=client,
             nexo_home=nexo_home,
             runtime_root=runtime_root or None,
             platform=target_platform or None,
         )
+        required_providers = {
+            str((entry.get("nexo") or {}).get("provider_id") or "").strip()
+            for entry in entries.values()
+            if isinstance(entry, dict)
+        }
+        required_providers.discard("")
+        if not required_providers:
+            return {}
+        for provider_id in required_providers:
+            state = providers.get(provider_id) if isinstance(providers.get(provider_id), dict) else {}
+            if state.get("status") != "healthy":
+                return {}
+        return entries
     except Exception:
         return {}
 
 
+def _remove_unhealthy_json_managed_mcp(payload: dict) -> dict:
+    if not remove_json_nexo_managed_mcp_servers:
+        return payload
+    return remove_json_nexo_managed_mcp_servers(payload)
+
+
+def _remove_unhealthy_toml_managed_mcp(payload: dict) -> dict:
+    if not remove_toml_nexo_managed_mcp_servers:
+        return payload
+    return remove_toml_nexo_managed_mcp_servers(payload)
+
+
 def _claude_code_settings_path(home: Path | None = None) -> Path:
     base = home or _user_home()
     return base / ".claude" / "settings.json"
@@ -1039,6 +1084,10 @@ def _sync_codex_managed_config(
             payload = merge_toml_mcp_servers(payload, managed_entries)
             codex_table = payload.setdefault("nexo", {}).setdefault("codex", {})
             codex_table["managed_default_mcp_count"] = len(managed_entries)
+        else:
+            payload = _remove_unhealthy_toml_managed_mcp(payload)
+            codex_table = payload.setdefault("nexo", {}).setdefault("codex", {})
+            codex_table["managed_default_mcp_count"] = 0
 
     # Ensure Codex headless crons (followup-runner, email-monitor, deep-sleep,
     # etc.) do not stall on approval prompts. Only set defaults when the user
@@ -1056,7 +1105,7 @@ def _sync_codex_managed_config(
         "hooks_enabled": True,
         "model": runtime_profile.get("model", ""),
         "reasoning_effort": runtime_profile.get("reasoning_effort", "") or "",
-        "managed_default_mcp_count": len(_managed_mcp_entries_for("codex", server_config)) if server_config else 0,
+        "managed_default_mcp_count": len(managed_entries) if server_config else 0,
     }
 
 
@@ -1450,6 +1499,8 @@ def _sync_json_client(path: Path, server_config: dict, label: str, *, managed_me
     managed_entries = _managed_mcp_entries_for(label, server_config)
     if managed_entries and merge_json_mcp_servers:
         payload = merge_json_mcp_servers(payload, managed_entries)
+    else:
+        payload = _remove_unhealthy_json_managed_mcp(payload)
     _write_json_object(path, payload)
     return {
         "ok": True,
@@ -1537,6 +1588,8 @@ def _sync_claude_code_settings(path: Path, server_config: dict) -> dict:
     managed_entries = _managed_mcp_entries_for("claude_code", server_config)
     if managed_entries and merge_json_mcp_servers:
         payload = merge_json_mcp_servers(payload, managed_entries)
+    else:
+        payload = _remove_unhealthy_json_managed_mcp(payload)
     _ensure_headless_permissions(payload)
     _write_json_object(path, payload)
     return {

package/src/managed_mcp/__init__.py

@@ -11,7 +11,12 @@ from .catalog import (
     provider_for_capability,
     validate_catalog_lock,
 )
-from .client_config import merge_json_mcp_servers, merge_toml_mcp_servers
+from .client_config import (
+    merge_json_mcp_servers,
+    merge_toml_mcp_servers,
+    remove_json_nexo_managed_mcp_servers,
+    remove_toml_nexo_managed_mcp_servers,
+)
 from .reconcile import managed_mcp_status, reconcile_managed_mcp
 
 __all__ = [
@@ -26,6 +31,8 @@ __all__ = [
     "validate_catalog_lock",
     "merge_json_mcp_servers",
     "merge_toml_mcp_servers",
+    "remove_json_nexo_managed_mcp_servers",
+    "remove_toml_nexo_managed_mcp_servers",
     "managed_mcp_status",
     "reconcile_managed_mcp",
 ]

package/src/managed_mcp/client_config.py

@@ -11,6 +11,47 @@ def _is_nexo_owned(entry: Any) -> bool:
     return isinstance(meta, dict) and meta.get("owner") == "nexo"
 
 
+def _managed_servers_metadata(container: dict[str, Any]) -> dict[str, Any]:
+    nexo_meta = container.get("nexo") if isinstance(container.get("nexo"), dict) else {}
+    managed = nexo_meta.get("managed_mcp") if isinstance(nexo_meta.get("managed_mcp"), dict) else {}
+    servers = managed.get("servers") if isinstance(managed.get("servers"), dict) else {}
+    return servers
+
+
+def _remove_nexo_owned_by_metadata(servers: dict[str, Any], managed_servers: dict[str, Any]) -> None:
+    for name, meta in list(managed_servers.items()):
+        if not (isinstance(meta, dict) and meta.get("owner") == "nexo"):
+            continue
+        current = servers.get(name)
+        if current is None or _is_nexo_owned(current) or name in servers:
+            servers.pop(name, None)
+        managed_servers.pop(name, None)
+
+
+def remove_json_nexo_managed_mcp_servers(payload: dict[str, Any]) -> dict[str, Any]:
+    result = deepcopy(payload) if isinstance(payload, dict) else {}
+    servers = result.get("mcpServers")
+    if not isinstance(servers, dict):
+        return result
+    managed_servers = _managed_servers_metadata(result)
+    for name, entry in list(servers.items()):
+        if _is_nexo_owned(entry):
+            servers.pop(name, None)
+            managed_servers.pop(name, None)
+    _remove_nexo_owned_by_metadata(servers, managed_servers)
+    return result
+
+
+def remove_toml_nexo_managed_mcp_servers(payload: dict[str, Any]) -> dict[str, Any]:
+    result = deepcopy(payload) if isinstance(payload, dict) else {}
+    servers = result.get("mcp_servers")
+    if not isinstance(servers, dict):
+        return result
+    managed_servers = _managed_servers_metadata(result)
+    _remove_nexo_owned_by_metadata(servers, managed_servers)
+    return result
+
+
 def merge_json_mcp_servers(payload: dict[str, Any], entries: dict[str, dict[str, Any]]) -> dict[str, Any]:
     result = deepcopy(payload) if isinstance(payload, dict) else {}
     servers = result.setdefault("mcpServers", {})