nexo-brain 7.30.19 → 7.30.21

package/src/managed_mcp/reconcile.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+from .catalog import build_managed_server_entries, load_catalog, load_lock, validate_catalog_lock
+
+
+def _state_dir(nexo_home: Path) -> Path:
+    return nexo_home / "runtime" / "managed-mcp"
+
+
+def _state_path(nexo_home: Path) -> Path:
+    return _state_dir(nexo_home) / "installed-state.json"
+
+
+def _read_state(nexo_home: Path) -> dict[str, Any]:
+    path = _state_path(nexo_home)
+    if not path.is_file():
+        return {}
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _write_state(nexo_home: Path, state: dict[str, Any]) -> None:
+    directory = _state_dir(nexo_home)
+    directory.mkdir(parents=True, exist_ok=True)
+    path = _state_path(nexo_home)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(state, indent=2, sort_keys=True) + "\n")
+    tmp.replace(path)
+
+
+def reconcile_managed_mcp(
+    *,
+    nexo_home: str | os.PathLike[str] | Path,
+    runtime_root: str | os.PathLike[str] | Path | None = None,
+    clients: list[str] | tuple[str, ...] | None = None,
+    apply: bool = False,
+    platform: str | None = None,
+) -> dict[str, Any]:
+    nexo_home_path = Path(nexo_home).expanduser()
+    catalog = load_catalog()
+    lock = load_lock()
+    validation = validate_catalog_lock(catalog, lock)
+    desired_clients = list(clients or ("claude_code", "claude_desktop", "codex"))
+    desired: dict[str, Any] = {}
+    for client in desired_clients:
+        desired[client] = build_managed_server_entries(
+            client=client,
+            nexo_home=nexo_home_path,
+            runtime_root=runtime_root,
+            catalog=catalog,
+            lock=lock,
+            platform=platform,
+        )
+    previous = _read_state(nexo_home_path)
+    previous_desired = previous.get("desired") if isinstance(previous.get("desired"), dict) else {}
+    actions: list[dict[str, str]] = []
+    for client, entries in desired.items():
+        old_entries = previous_desired.get(client) if isinstance(previous_desired, dict) else {}
+        old_entries = old_entries if isinstance(old_entries, dict) else {}
+        for name, entry in entries.items():
+            if name not in old_entries:
+                action = "install"
+            elif old_entries.get(name) != entry:
+                action = "update"
+            else:
+                action = "noop"
+            actions.append({"client": client, "server": name, "action": action})
+        for name in set(old_entries) - set(entries):
+            actions.append({"client": client, "server": name, "action": "disable"})
+
+    state = {
+        "schema": "nexo.managed_mcp.state.v1",
+        "catalog_version": catalog.get("catalog_version", ""),
+        "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "validation": validation,
+        "desired": desired,
+        "last_plan": actions,
+    }
+    if apply:
+        _write_state(nexo_home_path, state)
+    return {
+        "ok": validation["ok"],
+        "applied": bool(apply),
+        "state_path": str(_state_path(nexo_home_path)),
+        "validation": validation,
+        "actions": actions,
+        "desired_clients": sorted(desired),
+    }
+
+
+def managed_mcp_status(
+    *,
+    nexo_home: str | os.PathLike[str] | Path,
+    runtime_root: str | os.PathLike[str] | Path | None = None,
+    platform: str | None = None,
+) -> dict[str, Any]:
+    nexo_home_path = Path(nexo_home).expanduser()
+    state = _read_state(nexo_home_path)
+    plan = reconcile_managed_mcp(
+        nexo_home=nexo_home_path,
+        runtime_root=runtime_root,
+        apply=False,
+        platform=platform,
+    )
+    return {
+        "ok": plan["ok"],
+        "state_exists": _state_path(nexo_home_path).is_file(),
+        "state_path": str(_state_path(nexo_home_path)),
+        "catalog_version": plan["validation"].get("catalog_version", ""),
+        "validation": plan["validation"],
+        "last_applied_at": state.get("updated_at", ""),
+        "actions": plan["actions"],
+    }

package/src/plugins/update.py

@@ -1104,6 +1104,7 @@ def _backup_code_tree() -> tuple[str | None, str | None]:
         "cognitive",
         "dashboard",
         "local_context",
+        "product_knowledge",
         "rules",
         "crons",
         "scripts",

package/src/server.py

@@ -6,6 +6,7 @@ import signal
 import sys
 import json
 import time
+from pathlib import Path
 
 from fastmcp import FastMCP
 from core_prompts import render_core_prompt
@@ -1009,6 +1010,75 @@ def nexo_mcp_write_queue_status(limit: int = 20) -> str:
     return json.dumps(mcp_write_queue_status(limit=clean_limit), indent=2, ensure_ascii=False)
 
 
+@mcp.tool
+def nexo_managed_mcp_status(apply: bool = False) -> str:
+    """Read or apply the Brain-owned managed MCP catalog reconciliation plan."""
+    from managed_mcp import managed_mcp_status, reconcile_managed_mcp
+    import paths
+
+    runtime_root = Path(__file__).resolve().parent
+    if apply:
+        result = reconcile_managed_mcp(
+            nexo_home=paths.home(),
+            runtime_root=runtime_root,
+            apply=True,
+        )
+    else:
+        result = managed_mcp_status(
+            nexo_home=paths.home(),
+            runtime_root=runtime_root,
+        )
+    return json.dumps(result, indent=2, ensure_ascii=False)
+
+
+@mcp.tool
+def nexo_closure_status(refresh: bool = True, limit: int = 10) -> str:
+    """Read the Operational Closure Plane status and ranked closure queue."""
+    from closure_plane import handle_closure_status
+
+    try:
+        clean_limit = max(1, min(int(limit or 10), 100))
+    except Exception:
+        clean_limit = 10
+    return handle_closure_status(refresh=bool(refresh), limit=clean_limit)
+
+
+@mcp.tool
+def nexo_closure_next(limit: int = 10, include_waiting: bool = False, source: str = "", kind: str = "") -> str:
+    """Return the next ranked closure items without executing source actions."""
+    from closure_plane import handle_closure_next
+
+    try:
+        clean_limit = max(1, min(int(limit or 10), 100))
+    except Exception:
+        clean_limit = 10
+    return handle_closure_next(clean_limit, bool(include_waiting), source, kind)
+
+
+@mcp.tool
+def nexo_closure_item_get(item_id: str) -> str:
+    """Return one closure item with sources and events."""
+    from closure_plane import handle_closure_item_get
+
+    return handle_closure_item_get(item_id)
+
+
+@mcp.tool
+def nexo_closure_verify(item_id: str, evidence: str) -> str:
+    """Record verification evidence for a closure item."""
+    from closure_plane import handle_closure_verify
+
+    return handle_closure_verify(item_id, evidence)
+
+
+@mcp.tool
+def nexo_closure_close(item_id: str, reason: str = "completed") -> str:
+    """Close a verified closure item or reject/stale it explicitly."""
+    from closure_plane import handle_closure_close
+
+    return handle_closure_close(item_id, reason)
+
+
 @mcp.tool
 def nexo_local_index_status() -> str:
     """Return local memory index status for Desktop settings and support diagnostics."""

package/tool-enforcement-map.json

@@ -2864,6 +2864,96 @@
       },
       "triggers_after": []
     },
+    "nexo_managed_mcp_status": {
+      "description": "Read or apply the Brain-owned managed MCP catalog reconciliation plan",
+      "category": "system",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "managed_mcp_status"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_closure_status": {
+      "description": "Read Operational Closure Plane status and ranked closure queue",
+      "category": "closure",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "closure_status"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_closure_next": {
+      "description": "Return the next ranked closure items without executing source actions",
+      "category": "closure",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "closure_items"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_closure_item_get": {
+      "description": "Return one closure item with sources and events",
+      "category": "closure",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "closure_item"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_closure_verify": {
+      "description": "Record verification evidence for a closure item",
+      "category": "closure",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "closure_evidence"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
+    "nexo_closure_close": {
+      "description": "Close a verified closure item or mark it rejected/stale explicitly",
+      "category": "closure",
+      "source": "server",
+      "requires": [],
+      "provides": [
+        "closure_close_result"
+      ],
+      "internal_calls": [],
+      "enforcement": {
+        "level": "none",
+        "rules": []
+      },
+      "triggers_after": []
+    },
     "nexo_media_memory_add": {
       "description": "Store non-text artifact metadata",
       "category": "media",