nexo-brain 7.30.20 → 7.30.21

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.20",
+  "version": "7.30.21",
   "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.20` is the current packaged-runtime line. 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.
+Version `7.30.21` is the current packaged-runtime line. Patch release over v7.30.20 - Brain now ships managed default MCP catalog/lock reconciliation and the Operational Closure Plane, with Desktop v0.43.12 consuming the coordinated runtime contract.
+
+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.
 
 Previously in `7.30.19`: patch release over v7.30.18 - product capabilities now live in a structured, validated catalog with read-only discovery tools and preserved legacy system-catalog names.
 

package/bin/nexo-managed-mcp.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+function nexoHome() {
+  return process.env.NEXO_HOME || path.join(require("os").homedir(), ".nexo");
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (_) {
+    return null;
+  }
+}
+
+function findEntry(capabilityId) {
+  const state = readJson(path.join(nexoHome(), "runtime", "managed-mcp", "installed-state.json"));
+  const desired = state && state.desired && typeof state.desired === "object" ? state.desired : {};
+  for (const clientEntries of Object.values(desired)) {
+    if (!clientEntries || typeof clientEntries !== "object") continue;
+    for (const entry of Object.values(clientEntries)) {
+      const meta = entry && entry.nexo;
+      if (meta && meta.capability_id === capabilityId) return entry;
+    }
+  }
+  return null;
+}
+
+function providerEnv() {
+  return {
+    PATH: process.env.PATH || "",
+    HOME: process.env.HOME || "",
+    NEXO_HOME: nexoHome(),
+  };
+}
+
+function stagedProviderCommand(providerId) {
+  return path.join(nexoHome(), "runtime", "managed-mcp", "artifacts", providerId, "bin", providerId);
+}
+
+function spawnProvider(command, args, env) {
+  const child = spawn(command, args, {
+    stdio: "inherit",
+    env,
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    process.exit(typeof code === "number" ? code : 1);
+  });
+  child.on("error", (error) => {
+    console.error(`NEXO managed MCP failed to start: ${error && error.message ? error.message : String(error)}`);
+    process.exit(69);
+  });
+}
+
+function main() {
+  const [command, capabilityId] = process.argv.slice(2);
+  if (command !== "run" || !capabilityId) {
+    console.error("usage: nexo-managed-mcp run <capability_id>");
+    process.exit(64);
+  }
+  const entry = findEntry(capabilityId);
+  const meta = entry && entry.nexo ? entry.nexo : {};
+  const providerId = meta.provider_id || "";
+  if (!providerId) {
+    console.error(`NEXO managed MCP capability '${capabilityId}' is not installed yet.`);
+    process.exit(69);
+  }
+  const providerCommand = stagedProviderCommand(providerId);
+  const env = providerEnv();
+  if (!fs.existsSync(providerCommand)) {
+    const providerPackage = String(meta.provider_package || "");
+    const providerVersion = String(meta.provider_version || "");
+    const providerBin = String(meta.provider_bin || providerId);
+    if (!providerPackage || !providerVersion || providerVersion === "0.0.0-managed") {
+      console.error(`NEXO managed MCP provider '${providerId}' is not staged and has no exact locked npm package.`);
+      process.exit(69);
+    }
+    const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
+    spawnProvider(npxBin, ["--yes", "--package", `${providerPackage}@${providerVersion}`, providerBin], env);
+    return;
+  }
+  spawnProvider(providerCommand, [], env);
+}
+
+main();

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.20",
+  "version": "7.30.21",
   "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",
   "bin": {
     "nexo-brain": "bin/nexo-brain.js",
-    "nexo": "bin/nexo.js"
+    "nexo": "bin/nexo.js",
+    "nexo-managed-mcp": "bin/nexo-managed-mcp.js"
   },
   "keywords": [
     "claude-code",
@@ -78,6 +79,7 @@
   "files": [
     "bin/nexo-brain.js",
     "bin/nexo.js",
+    "bin/nexo-managed-mcp.js",
     "bin/windows-wsl-bridge.js",
     "bin/postinstall.js",
     "scripts/sync_release_artifacts.py",

package/src/client_sync.py

@@ -23,6 +23,13 @@ except ModuleNotFoundError:  # Python < 3.11
 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
+except Exception:
+    build_managed_server_entries = None
+    merge_json_mcp_servers = None
+    merge_toml_mcp_servers = None
+
 try:
     from client_preferences import (
         BACKEND_NONE,
@@ -832,6 +839,32 @@ def build_server_config(
     return 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:
+        return {}
+    env = server_config.get("env") if isinstance(server_config.get("env"), dict) else {}
+    nexo_home = str(env.get("NEXO_HOME") or "").strip()
+    runtime_root = str(env.get("NEXO_CODE") or "").strip()
+    if not nexo_home:
+        return {}
+    target_platform = str(
+        os.environ.get("NEXO_MANAGED_MCP_PLATFORM")
+        or env.get("NEXO_MANAGED_MCP_PLATFORM")
+        or ""
+    ).strip()
+    try:
+        return build_managed_server_entries(
+            client=client,
+            nexo_home=nexo_home,
+            runtime_root=runtime_root or None,
+            platform=target_platform or None,
+        )
+    except Exception:
+        return {}
+
+
 def _claude_code_settings_path(home: Path | None = None) -> Path:
     base = home or _user_home()
     return base / ".claude" / "settings.json"
@@ -1001,6 +1034,11 @@ def _sync_codex_managed_config(
             "env": dict(server_config.get("env", {}) or {}),
         }
         codex_table["managed_server_command"] = server_config.get("command", "")
+        managed_entries = _managed_mcp_entries_for("codex", server_config)
+        if managed_entries and merge_toml_mcp_servers:
+            payload = merge_toml_mcp_servers(payload, managed_entries)
+            codex_table = payload.setdefault("nexo", {}).setdefault("codex", {})
+            codex_table["managed_default_mcp_count"] = len(managed_entries)
 
     # Ensure Codex headless crons (followup-runner, email-monitor, deep-sleep,
     # etc.) do not stall on approval prompts. Only set defaults when the user
@@ -1018,6 +1056,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,
     }
 
 
@@ -1408,12 +1447,16 @@ def _sync_json_client(path: Path, server_config: dict, label: str, *, managed_me
             nexo_meta = {}
             payload["nexo"] = nexo_meta
         nexo_meta.update(managed_metadata)
+    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)
     _write_json_object(path, payload)
     return {
         "ok": True,
         "client": label,
         "action": action,
         "path": str(path),
+        "managed_default_mcp_count": len(managed_entries),
     }
 
 
@@ -1491,6 +1534,9 @@ def _sync_claude_code_settings(path: Path, server_config: dict) -> dict:
         runtime_root=runtime_root,
         nexo_home=nexo_home,
     )
+    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)
     _ensure_headless_permissions(payload)
     _write_json_object(path, payload)
     return {
@@ -1499,6 +1545,7 @@ def _sync_claude_code_settings(path: Path, server_config: dict) -> dict:
         "action": action,
         "path": str(path),
         "managed_hook_count": managed_hook_count,
+        "managed_default_mcp_count": len(managed_entries),
     }