nexo-brain 7.27.0 → 7.27.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.27.0",
+  "version": "7.27.2",
   "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,11 @@
 
 [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.27.0` is the current packaged-runtime line. Minor release over v7.26.0 - Codex-side defaults move to verified `gpt-5.5` resonance tiers, managed config healing follows that model family, and Local Memory file-type actions tolerate transient SQLite locks.
+Version `7.27.2` is the current packaged-runtime line. Patch release over v7.27.1 - legacy Codex preferences now migrate to OpenAI correctly, and the F0.6 config-folder transition keeps reading existing `config/schedule.json` before it is moved.
+
+Previously in `7.27.1`: patch release over v7.27.0 - lifecycle stop calls skip external provider session UUIDs safely, and provider runtime selection keeps chat plus automation aligned to the same Anthropic/OpenAI account.
+
+Previously in `7.27.0`: minor release over v7.26.0 - Codex-side defaults move to verified `gpt-5.5` resonance tiers, managed config healing follows that model family, and Local Memory file-type actions tolerate transient SQLite locks.
 
 Previously in `7.26.0`: minor release over v7.25.6 - provider runtime parity lets Desktop-managed Brain choose Anthropic or OpenAI, keep provider metadata on sessions/automation/crons, and provision the managed OpenAI runtime from bundled Desktop resources.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.27.0",
+  "version": "7.27.2",
   "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/cli.py

@@ -2519,6 +2519,7 @@ def _preferences(args):
         PROVIDER_KEYS,
         PROVIDER_NONE,
         load_client_preferences,
+        normalize_provider_key,
         normalize_default_terminal_client,
         save_client_preferences,
     )
@@ -2554,6 +2555,18 @@ def _preferences(args):
             file=sys.stderr,
         )
         return 2
+    normalized_chat_provider = normalize_provider_key(chat_provider)
+    normalized_automation_provider = normalize_provider_key(automation_provider)
+    if (
+        normalized_chat_provider in PROVIDER_KEYS
+        and normalized_automation_provider in PROVIDER_KEYS
+        and normalized_chat_provider != normalized_automation_provider
+    ):
+        print(
+            "[NEXO] Chat and background automation must use the same provider.",
+            file=sys.stderr,
+        )
+        return 2
 
     if args.resonance:
         tier = args.resonance.lower()
@@ -2668,12 +2681,16 @@ def _provider(args):
         if target not in PROVIDER_KEYS:
             print(f"[NEXO] Unknown provider '{target}'. Valid values: {', '.join(PROVIDER_KEYS)}.", file=sys.stderr)
             return 2
-        chat_provider = None if getattr(args, "automation_only", False) else target
-        automation_provider = None if getattr(args, "chat_only", False) else target
+        if getattr(args, "automation_only", False) or getattr(args, "chat_only", False):
+            print(
+                "[NEXO] Provider selection is unified: chat and background automation use the same provider.",
+                file=sys.stderr,
+            )
+            return 2
         save_client_preferences(
-            selected_chat_provider=chat_provider,
-            automation_provider=automation_provider,
-            automation_user_override=True if automation_provider is not None else None,
+            selected_chat_provider=target,
+            automation_provider=target,
+            automation_user_override=True,
         )
         prefs = load_client_preferences()
         provider_runtime = prefs.get("provider_runtime") if isinstance(prefs.get("provider_runtime"), dict) else {}

package/src/client_preferences.py

@@ -373,6 +373,21 @@ def _provider_from_runtime_payload(value, key: str, fallback_client: str) -> str
     return client_to_provider(fallback_client) or PROVIDER_ANTHROPIC
 
 
+def _provider_runtime_is_unselected_default(value) -> bool:
+    if not isinstance(value, dict):
+        return False
+    selected = normalize_provider_key(value.get("selected_chat_provider"))
+    automation_provider = normalize_provider_key(value.get("automation_provider"))
+    automation_backend = normalize_backend_key(value.get("automation_backend"))
+    last_change = value.get("last_provider_change") if isinstance(value.get("last_provider_change"), dict) else {}
+    return (
+        selected == PROVIDER_ANTHROPIC
+        and automation_provider in {"", PROVIDER_ANTHROPIC}
+        and automation_backend in {"", CLIENT_CLAUDE_CODE}
+        and not last_change.get("changed_at")
+    )
+
+
 def normalize_provider_runtime(
     value,
     *,
@@ -388,19 +403,17 @@ def normalize_provider_runtime(
         default_terminal_client,
     )
     raw_automation_provider = normalize_provider_key(raw.get("automation_provider")) if isinstance(raw, dict) else ""
-    automation_provider = (
-        PROVIDER_NONE
-        if raw_automation_provider == PROVIDER_NONE
-        else _provider_from_runtime_payload(
-            raw,
-            "automation_provider",
-            automation_backend if automation_enabled else BACKEND_NONE,
-        )
-    )
-    if not automation_enabled or automation_backend == BACKEND_NONE:
+    raw_has_automation_backend = isinstance(raw, dict) and "automation_backend" in raw
+    raw_automation_backend = normalize_backend_key(raw.get("automation_backend")) if raw_has_automation_backend else ""
+    if (
+        not automation_enabled
+        or automation_backend == BACKEND_NONE
+        or raw_automation_provider == PROVIDER_NONE
+        or (raw_has_automation_backend and raw_automation_backend == BACKEND_NONE)
+    ):
         automation_provider = PROVIDER_NONE
-    elif automation_provider not in PROVIDER_KEYS:
-        automation_provider = client_to_provider(automation_backend) or PROVIDER_ANTHROPIC
+    else:
+        automation_provider = selected_provider
 
     providers = defaults["providers"]
     raw_providers = raw.get("providers") if isinstance(raw.get("providers"), dict) else {}
@@ -692,8 +705,19 @@ def normalize_client_preferences(
     runtime_profiles = normalize_client_runtime_profiles(
         schedule.get("client_runtime_profiles")
     )
+    raw_provider_runtime = schedule.get("provider_runtime")
+    legacy_terminal_provider = client_to_provider(default_terminal_client)
+    if (
+        legacy_terminal_provider in PROVIDER_KEYS
+        and legacy_terminal_provider != PROVIDER_ANTHROPIC
+        and _provider_runtime_is_unselected_default(raw_provider_runtime)
+    ):
+        raw_provider_runtime = dict(raw_provider_runtime or {})
+        raw_provider_runtime["selected_chat_provider"] = legacy_terminal_provider
+        raw_provider_runtime["automation_provider"] = legacy_terminal_provider
+        raw_provider_runtime["automation_backend"] = provider_to_client(legacy_terminal_provider)
     provider_runtime = normalize_provider_runtime(
-        schedule.get("provider_runtime"),
+        raw_provider_runtime,
         default_terminal_client=default_terminal_client,
         automation_backend=automation_backend,
         automation_enabled=automation_enabled,
@@ -786,28 +810,53 @@ def apply_client_preferences(
         else current.get("provider_runtime")
     )
     raw_provider_runtime = dict(raw_provider_runtime or {})
-    if selected_chat_provider is not None:
-        raw_provider_runtime["selected_chat_provider"] = selected_chat_provider
-        derived_chat_client = provider_to_client(selected_chat_provider)
-        if derived_chat_client:
-            merged["interactive_clients"][derived_chat_client] = True
-            merged["default_terminal_client"] = derived_chat_client
+    explicit_selected_provider = normalize_provider_key(selected_chat_provider)
+    explicit_automation_provider = normalize_provider_key(automation_provider)
+    backend_provider = (
+        client_to_provider(merged["automation_backend"])
+        if merged["automation_backend"] != BACKEND_NONE
+        else ""
+    )
+    terminal_provider = (
+        client_to_provider(merged["default_terminal_client"])
+        if default_terminal_client is not None
+        else ""
+    )
+    single_provider = (
+        (explicit_selected_provider if explicit_selected_provider != PROVIDER_NONE else "")
+        or (explicit_automation_provider if explicit_automation_provider != PROVIDER_NONE else "")
+        or (backend_provider if automation_backend is not None else "")
+        or terminal_provider
+    )
+    if single_provider in PROVIDER_KEYS:
+        raw_provider_runtime["selected_chat_provider"] = single_provider
+        selected_client = provider_to_client(single_provider)
+        if selected_client:
+            merged["interactive_clients"][selected_client] = True
+            merged["default_terminal_client"] = selected_client
     elif default_terminal_client is not None:
         raw_provider_runtime["selected_chat_provider"] = client_to_provider(
             merged["default_terminal_client"]
         )
-    if automation_provider is not None:
-        raw_provider_runtime["automation_provider"] = automation_provider
-        derived_backend = provider_to_client(automation_provider)
-        if derived_backend:
-            merged["interactive_clients"][derived_backend] = True
-        merged["automation_backend"] = (
-            derived_backend if derived_backend else BACKEND_NONE
-        )
+
+    automation_off = (
+        merged["automation_enabled"] is False
+        or merged["automation_backend"] == BACKEND_NONE
+        or explicit_automation_provider == PROVIDER_NONE
+    )
+    if automation_off:
+        raw_provider_runtime["automation_provider"] = PROVIDER_NONE
+        raw_provider_runtime["automation_backend"] = BACKEND_NONE
+        merged["automation_backend"] = BACKEND_NONE
+    elif single_provider in PROVIDER_KEYS:
+        raw_provider_runtime["automation_provider"] = single_provider
+        merged["automation_backend"] = provider_to_client(single_provider)
+        raw_provider_runtime["automation_backend"] = merged["automation_backend"]
     elif automation_backend is not None or automation_enabled is not None:
         raw_provider_runtime["automation_provider"] = client_to_provider(
             merged["automation_backend"]
         ) if merged["automation_backend"] != BACKEND_NONE else PROVIDER_NONE
+        raw_provider_runtime["automation_backend"] = merged["automation_backend"]
     merged["provider_runtime"] = normalize_provider_runtime(
         raw_provider_runtime,
         default_terminal_client=merged["default_terminal_client"],
@@ -977,7 +1026,7 @@ def detect_installed_clients(user_home: str | os.PathLike[str] | None = None) ->
 
 
 def resolve_terminal_client(requested: str | None = None, *, preferences: dict | None = None) -> str:
-    normalized = preferences or load_client_preferences()
+    normalized = normalize_client_preferences(preferences) if preferences is not None else load_client_preferences()
     if requested is not None:
         interactive_clients = normalized["interactive_clients"]
         return normalize_default_terminal_client(requested, interactive_clients=interactive_clients)
@@ -988,7 +1037,7 @@ def resolve_terminal_client(requested: str | None = None, *, preferences: dict |
 
 
 def resolve_selected_chat_provider(preferences: dict | None = None) -> str:
-    normalized = preferences or load_client_preferences()
+    normalized = normalize_client_preferences(preferences) if preferences is not None else load_client_preferences()
     provider_runtime = normalize_provider_runtime(
         normalized.get("provider_runtime"),
         default_terminal_client=normalized.get("default_terminal_client", CLIENT_CLAUDE_CODE),
@@ -999,7 +1048,7 @@ def resolve_selected_chat_provider(preferences: dict | None = None) -> str:
 
 
 def resolve_automation_provider(preferences: dict | None = None) -> str:
-    normalized = preferences or load_client_preferences()
+    normalized = normalize_client_preferences(preferences) if preferences is not None else load_client_preferences()
     provider_runtime = normalize_provider_runtime(
         normalized.get("provider_runtime"),
         default_terminal_client=normalized.get("default_terminal_client", CLIENT_CLAUDE_CODE),
@@ -1016,7 +1065,7 @@ def resolve_user_model(preferences: dict | None = None) -> str:
     string.  The value comes from the user's ``client_runtime_profiles`` for
     their ``default_terminal_client`` (usually ``claude_code``).
     """
-    normalized = preferences or load_client_preferences()
+    normalized = normalize_client_preferences(preferences) if preferences is not None else load_client_preferences()
     client = normalize_default_terminal_client(
         normalized["default_terminal_client"],
         interactive_clients=normalized["interactive_clients"],
@@ -1026,11 +1075,8 @@ def resolve_user_model(preferences: dict | None = None) -> str:
 
 
 def resolve_automation_backend(preferences: dict | None = None) -> str:
-    normalized = preferences or load_client_preferences()
-    return normalize_automation_backend(
-        normalized["automation_backend"],
-        automation_enabled=normalized["automation_enabled"],
-    )
+    normalized = normalize_client_preferences(preferences) if preferences is not None else load_client_preferences()
+    return normalized["automation_backend"]
 
 
 def resolve_client_runtime_profile(

package/src/plugins/lifecycle_events.py

@@ -218,7 +218,15 @@ def handle_nexo_lifecycle_stop_nexo_session(
         from tools_sessions import handle_stop
 
         raw_sid = str(sid or "").strip()
-        stop_sids = lifecycle_events.registered_stop_session_ids(raw_sid) or [raw_sid]
+        stop_sids = lifecycle_events.registered_stop_session_ids(raw_sid)
+        if not stop_sids:
+            return json.dumps({
+                "status": "ok",
+                "sid": raw_sid,
+                "stopped_session_ids": [],
+                "skipped": True,
+                "reason": "no-registered-nexo-session",
+            }, ensure_ascii=False)
         messages = [handle_stop(stop_sid) for stop_sid in stop_sids]
         return json.dumps({
             "status": "ok",

package/src/runtime_power.py

@@ -337,6 +337,23 @@ def _schedule_defaults() -> dict:
         "default_terminal_client": "claude_code",
         "automation_enabled": True,
         "automation_backend": "claude_code",
+        "provider_runtime": {
+            "schema_version": 1,
+            "selected_chat_provider": "anthropic",
+            "automation_provider": "anthropic",
+            "automation_backend": "claude_code",
+            "providers": {
+                "anthropic": {"client": "claude_code"},
+                "openai": {"client": "codex"},
+            },
+            "fallback_policy": {"chat": "ask", "automation": "fail_closed"},
+            "last_provider_change": {
+                "changed_at": None,
+                "from_provider": None,
+                "to_provider": None,
+                "source": None,
+            },
+        },
         "client_runtime_profiles": {
             "claude_code": {
                 "model": DEFAULT_CLAUDE_CODE_MODEL,
@@ -361,16 +378,32 @@ def _schedule_defaults() -> dict:
     }
 
 
-def load_schedule_config() -> dict:
-    if not SCHEDULE_FILE.is_file():
-        return _schedule_defaults()
+def _load_schedule_payload(path: Path) -> dict | None:
     try:
-        data = json.loads(SCHEDULE_FILE.read_text())
+        data = json.loads(path.read_text())
     except Exception:
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _legacy_schedule_file() -> Path:
+    return NEXO_HOME / "config" / "schedule.json"
+
+
+def load_schedule_config() -> dict:
+    data: dict | None = None
+    if SCHEDULE_FILE.is_file():
+        data = _load_schedule_payload(SCHEDULE_FILE)
+    else:
+        legacy_file = _legacy_schedule_file()
+        if legacy_file != SCHEDULE_FILE and legacy_file.is_file():
+            data = _load_schedule_payload(legacy_file)
+    if data is None:
         return _schedule_defaults()
-    if not isinstance(data, dict):
-        return _schedule_defaults()
-    merged = _schedule_defaults()
+    defaults = _schedule_defaults()
+    if "provider_runtime" not in data:
+        defaults.pop("provider_runtime", None)
+    merged = defaults
     merged.update(data)
     merged.setdefault("processes", {})
     return merged

package/src/scripts/nexo-cron-wrapper.sh

@@ -63,11 +63,33 @@ for candidate in (
     except Exception:
         continue
 
-provider_runtime = schedule.get("provider_runtime") if isinstance(schedule.get("provider_runtime"), dict) else {}
-backend = str(provider_runtime.get("automation_backend") or schedule.get("automation_backend") or "claude_code").strip().lower()
-provider = str(provider_runtime.get("automation_provider") or "").strip().lower()
-if provider not in {"anthropic", "openai", "none"}:
-    provider = {"claude_code": "anthropic", "codex": "openai", "none": "none"}.get(backend, "")
+for import_root in (
+    nexo_home / "core",
+    nexo_home / "core" / "src",
+    nexo_home / "src",
+):
+    if import_root.exists():
+        sys.path.insert(0, str(import_root))
+try:
+    from client_preferences import normalize_client_preferences  # type: ignore
+    prefs = normalize_client_preferences(schedule)
+    provider_runtime = prefs.get("provider_runtime") if isinstance(prefs.get("provider_runtime"), dict) else {}
+    provider = str(provider_runtime.get("automation_provider") or "none").strip().lower()
+    backend = str(prefs.get("automation_backend") or provider_runtime.get("automation_backend") or "none").strip().lower()
+except Exception:
+    provider_runtime = schedule.get("provider_runtime") if isinstance(schedule.get("provider_runtime"), dict) else {}
+    selected = str(provider_runtime.get("selected_chat_provider") or "").strip().lower()
+    backend_raw = str(provider_runtime.get("automation_backend") or schedule.get("automation_backend") or "claude_code").strip().lower()
+    provider_raw = str(provider_runtime.get("automation_provider") or "").strip().lower()
+    automation_enabled = schedule.get("automation_enabled", True) is not False
+    backend_map = {"claude_code": "anthropic", "codex": "openai", "none": "none"}
+    provider_map = {"anthropic": "anthropic", "openai": "openai", "none": "none"}
+    if (not automation_enabled) or backend_raw in {"none", "off", "disabled", "false", "0"} or provider_raw in {"none", "off", "disabled", "false", "0"}:
+        provider = "none"
+        backend = "none"
+    else:
+        provider = provider_map.get(selected) or provider_map.get(provider_raw) or backend_map.get(backend_raw, "anthropic")
+        backend = {"anthropic": "claude_code", "openai": "codex", "none": "none"}.get(provider, "claude_code")
 snapshot = {
     "selected_chat_provider": provider_runtime.get("selected_chat_provider") or "",
     "automation_provider": provider,

package/templates/nexo_helper.py

@@ -76,7 +76,24 @@ def _resolve_core_runner(script_name: str) -> Path:
 
 def _resolve_automation_backend() -> str:
     data = _load_schedule()
-    return str(data.get("automation_backend", "claude_code") or "claude_code")
+    provider_runtime = data.get("provider_runtime") if isinstance(data.get("provider_runtime"), dict) else {}
+    selected = str(provider_runtime.get("selected_chat_provider") or "").strip().lower()
+    backend_raw = str(provider_runtime.get("automation_backend") or data.get("automation_backend") or "claude_code").strip().lower()
+    provider_raw = str(provider_runtime.get("automation_provider") or "").strip().lower()
+    automation_enabled = data.get("automation_enabled", True) is not False
+    if (
+        not automation_enabled
+        or backend_raw in {"none", "off", "disabled", "false", "0"}
+        or provider_raw in {"none", "off", "disabled", "false", "0"}
+    ):
+        return "none"
+    provider = (
+        {"anthropic": "anthropic", "openai": "openai"}.get(selected)
+        or {"anthropic": "anthropic", "openai": "openai"}.get(provider_raw)
+        or {"claude_code": "anthropic", "codex": "openai"}.get(backend_raw)
+        or "anthropic"
+    )
+    return {"anthropic": "claude_code", "openai": "codex"}.get(provider, "claude_code")
 
 
 def _load_bootstrap_prompt() -> str: