nexo-brain 7.30.22 → 7.30.24

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.22",
+  "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.22` is the current packaged-runtime line. Patch release over v7.30.21 - Brain now ships managed default MCP catalog/lock reconciliation and the Operational Closure Plane, with Desktop v0.43.14 consuming the coordinated runtime contract.
+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.
 
@@ -26,6 +28,8 @@ Previously in `7.30.19`: patch release over v7.30.18 - product capabilities now
 
 Previously in `7.30.16`: patch release over v7.30.14 - Desktop diagnostics can read embedding migration status without warming models, and the coordinated Desktop update path is covered for bundled model verification and obsolete managed model cleanup.
 
+Previously in `7.30.15`: patch release over v7.30.14 - Email NEXO closes affirmative actionable replies correctly and avoids reopening processed threads after a sent reply is already recorded.
+
 Previously in `7.30.14`: patch release over v7.30.13 - support tickets, provider capability discovery, task-close rearming, internal audit followups, and the memory-observation watchdog are aligned for Desktop-managed agents.
 
 Previously in `7.30.13`: patch release over v7.30.12 - Email NEXO monitor prompts now require a full IMAP body fetch before replying, and managed email defaults use the MXroute `Sent` folder instead of `INBOX.Sent`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.22",
+  "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/db/_schema.py

@@ -2903,6 +2903,166 @@ def _m79_operational_closure_links_readiness(conn):
     _migrate_add_index(conn, "idx_closure_readiness_capability", "closure_capability_readiness", "capability, status")
 
 
+def _m80_opportunity_orchestrator(conn):
+    """Opportunity Orchestrator v1: sparse, evidence-backed proactive queue."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_signals (
+            id TEXT PRIMARY KEY,
+            source_type TEXT NOT NULL,
+            source_id TEXT NOT NULL DEFAULT '',
+            entity_ref TEXT NOT NULL DEFAULT '',
+            summary TEXT NOT NULL DEFAULT '',
+            signal_kind TEXT NOT NULL,
+            urgency REAL NOT NULL DEFAULT 0,
+            confidence REAL NOT NULL DEFAULT 0,
+            privacy_level TEXT NOT NULL DEFAULT 'normal',
+            source_hash TEXT NOT NULL,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            expires_at TEXT NOT NULL DEFAULT '',
+            UNIQUE(source_type, source_id, signal_kind)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_opportunities (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            hypothesis TEXT NOT NULL DEFAULT '',
+            domain TEXT NOT NULL DEFAULT 'general',
+            opportunity_type TEXT NOT NULL,
+            dedupe_key TEXT NOT NULL,
+            impact REAL NOT NULL DEFAULT 0,
+            urgency REAL NOT NULL DEFAULT 0,
+            confidence REAL NOT NULL DEFAULT 0,
+            risk REAL NOT NULL DEFAULT 0,
+            effort REAL NOT NULL DEFAULT 0,
+            readiness REAL NOT NULL DEFAULT 0,
+            user_burden_reduction REAL NOT NULL DEFAULT 0,
+            interruption_cost REAL NOT NULL DEFAULT 0,
+            strategic_alignment REAL NOT NULL DEFAULT 0,
+            repetition_penalty REAL NOT NULL DEFAULT 0,
+            score REAL NOT NULL DEFAULT 0,
+            state TEXT NOT NULL DEFAULT 'candidate',
+            owner TEXT NOT NULL DEFAULT 'nero',
+            why_now TEXT NOT NULL DEFAULT '',
+            next_action TEXT NOT NULL DEFAULT '',
+            action_class TEXT NOT NULL DEFAULT 'read_only',
+            authorization_status TEXT NOT NULL DEFAULT 'not_required',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+            expires_at TEXT NOT NULL DEFAULT '',
+            last_proposed_at TEXT NOT NULL DEFAULT '',
+            source_payload_json TEXT NOT NULL DEFAULT '{}',
+            UNIQUE(dedupe_key)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_opportunity_evidence (
+            id TEXT PRIMARY KEY,
+            opportunity_id TEXT NOT NULL,
+            source_type TEXT NOT NULL,
+            source_id TEXT NOT NULL,
+            evidence_summary TEXT NOT NULL DEFAULT '',
+            confidence REAL NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY(opportunity_id) REFERENCES nexo_opportunities(id) ON DELETE CASCADE,
+            UNIQUE(opportunity_id, source_type, source_id)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_preparations (
+            id TEXT PRIMARY KEY,
+            opportunity_id TEXT NOT NULL,
+            artifact_type TEXT NOT NULL,
+            artifact_ref TEXT NOT NULL DEFAULT '',
+            safe_mode INTEGER NOT NULL DEFAULT 1,
+            approval_required INTEGER NOT NULL DEFAULT 0,
+            status TEXT NOT NULL DEFAULT 'ready',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            expires_at TEXT NOT NULL DEFAULT '',
+            FOREIGN KEY(opportunity_id) REFERENCES nexo_opportunities(id) ON DELETE CASCADE,
+            UNIQUE(opportunity_id, artifact_type, artifact_ref)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_proposals (
+            id TEXT PRIMARY KEY,
+            opportunity_id TEXT NOT NULL,
+            surface TEXT NOT NULL DEFAULT 'home',
+            copy TEXT NOT NULL DEFAULT '',
+            cta_primary TEXT NOT NULL DEFAULT 'Inspect evidence',
+            cta_secondary TEXT NOT NULL DEFAULT 'Snooze',
+            shown_at TEXT NOT NULL DEFAULT '',
+            feedback TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY(opportunity_id) REFERENCES nexo_opportunities(id) ON DELETE CASCADE,
+            UNIQUE(opportunity_id, surface)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_proposal_events (
+            id TEXT PRIMARY KEY,
+            proposal_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            feedback TEXT NOT NULL DEFAULT '',
+            note TEXT NOT NULL DEFAULT '',
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            FOREIGN KEY(proposal_id) REFERENCES nexo_proposals(id) ON DELETE CASCADE
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_suppression_rules (
+            id TEXT PRIMARY KEY,
+            scope_type TEXT NOT NULL,
+            scope_key TEXT NOT NULL,
+            reason TEXT NOT NULL DEFAULT '',
+            expires_at TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            UNIQUE(scope_type, scope_key, reason)
+        )
+        """
+    )
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS nexo_action_authorizations (
+            id TEXT PRIMARY KEY,
+            scope TEXT NOT NULL,
+            allowed_action_class TEXT NOT NULL,
+            max_cost REAL NOT NULL DEFAULT 0,
+            expires_at TEXT NOT NULL DEFAULT '',
+            granted_by TEXT NOT NULL DEFAULT '',
+            evidence_ref TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            UNIQUE(scope, allowed_action_class, evidence_ref)
+        )
+        """
+    )
+    _migrate_add_index(conn, "idx_nexo_signals_source", "nexo_signals", "source_type, source_id")
+    _migrate_add_index(conn, "idx_nexo_signals_expires", "nexo_signals", "expires_at")
+    _migrate_add_index(conn, "idx_nexo_opportunities_state_score", "nexo_opportunities", "state, score DESC, updated_at")
+    _migrate_add_index(conn, "idx_nexo_opportunities_type", "nexo_opportunities", "opportunity_type, state")
+    _migrate_add_index(conn, "idx_nexo_opportunities_expires", "nexo_opportunities", "expires_at")
+    _migrate_add_index(conn, "idx_nexo_opportunity_evidence_item", "nexo_opportunity_evidence", "opportunity_id")
+    _migrate_add_index(conn, "idx_nexo_preparations_item", "nexo_preparations", "opportunity_id, status")
+    _migrate_add_index(conn, "idx_nexo_proposals_surface", "nexo_proposals", "surface, feedback")
+    _migrate_add_index(conn, "idx_nexo_proposal_events_proposal", "nexo_proposal_events", "proposal_id, created_at")
+    _migrate_add_index(conn, "idx_nexo_suppression_scope", "nexo_suppression_rules", "scope_type, scope_key")
+    _migrate_add_index(conn, "idx_nexo_authorizations_scope", "nexo_action_authorizations", "scope, allowed_action_class")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2983,6 +3143,7 @@ MIGRATIONS = [
     (77, "morning_briefing_presentation", _m77_morning_briefing_presentation),
     (78, "operational_closure_plane", _m78_operational_closure_plane),
     (79, "operational_closure_links_readiness", _m79_operational_closure_links_readiness),
+    (80, "opportunity_orchestrator", _m80_opportunity_orchestrator),
 ]
 
 

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", {})