nexo-brain 7.26.0 → 7.27.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.26.0",
+  "version": "7.27.1",
   "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.26.0` is the current packaged-runtime line. Minor release over v7.25.6 - provider runtime parity lets Desktop-managed Brain choose Anthropic Claude or OpenAI Codex, keep provider metadata on sessions/automation/crons, and provision the managed Codex runtime from bundled Desktop resources.
+Version `7.27.1` is the current packaged-runtime line. Patch release over v7.27.0 - lifecycle stop calls now 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.
 
 Previously in `7.25.6`: patch release over v7.25.5 - existing Local Memory sidecar databases repair legacy root/exclusion columns before source-dependent indexes are created, and core background crons prefer the NEXO-managed Python runtime.
 

package/bin/nexo-brain.js

@@ -115,8 +115,8 @@ const PUBLIC_CONTRIBUTION_UPSTREAM = "wazionapps/nexo";
 const MODEL_DEFAULTS_PATH = path.join(__dirname, "..", "src", "model_defaults.json");
 function _loadModelDefaults() {
   const fallback = {
-    claude_code: { model: "claude-opus-4-6[1m]", reasoning_effort: "", display_name: "Opus 4.6 with 1M context" },
-    codex: { model: "gpt-5.4", reasoning_effort: "xhigh", display_name: "GPT-5.4 with max reasoning" },
+    claude_code: { model: "claude-opus-4-7[1m]", reasoning_effort: "max", display_name: "Opus 4.7 with 1M context" },
+    codex: { model: "gpt-5.5", reasoning_effort: "xhigh", display_name: "GPT-5.5 with max reasoning" },
   };
   try {
     const raw = JSON.parse(fs.readFileSync(MODEL_DEFAULTS_PATH, "utf8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.26.0",
+  "version": "7.27.1",
   "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/agent_runner.py

@@ -44,6 +44,7 @@ CLAUDE_LEGACY_MODEL_HINTS = {"opus", "sonnet"}
 MODEL_PRICING_USD_PER_1M = {
     # Pricing snapshot used only when the backend does not return explicit cost.
     # Codex model names map to the current GPT-5 family pricing.
+    "gpt-5.5": {"input": 1.25, "cached_input": 0.125, "output": 10.0},
     "gpt-5.4": {"input": 1.25, "cached_input": 0.125, "output": 10.0},
     "gpt-5.4-mini": {"input": 0.25, "cached_input": 0.025, "output": 2.0},
 }
@@ -66,7 +67,8 @@ def _canonical_pricing_model(model: str) -> str:
     lowered = str(model or "").strip().lower()
     lowered = lowered.split("[", 1)[0]
     aliases = {
-        "gpt-5": "gpt-5.4",
+        "gpt-5": "gpt-5.5",
+        "gpt-5.5": "gpt-5.5",
         "gpt-5.4": "gpt-5.4",
         "gpt-5-mini": "gpt-5.4-mini",
         "gpt-5.4-mini": "gpt-5.4-mini",

package/src/call_model_raw.py

@@ -260,7 +260,7 @@ def call_model_raw(
     Parameters follow the Fase 2 plan doc 1 spec:
 
         prompt          — the user-role text (English or the model's default).
-        tier            — resonance tier; default "muy_bajo" → Haiku / gpt-5.4-mini.
+        tier            — resonance tier; default "muy_bajo" → Haiku / gpt-5.5 low.
         caller          — resonance caller label. Must be registered in
                           resonance_map.SYSTEM_OWNED_CALLERS. Default
                           "enforcer_classifier".

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

@@ -203,12 +203,15 @@ def _managed_codex_vendor_present(home: Path | None = None) -> bool:
         managed_prefix / "node_modules" / "@openai" / "codex",
     )
     for package_root in package_roots:
-        vendor_root = package_root / "vendor"
-        if not vendor_root.exists():
-            continue
+        vendor_roots = [package_root / "vendor"]
+        optional_root = package_root / "node_modules" / "@openai"
+        if optional_root.is_dir():
+            vendor_roots.extend(item / "vendor" for item in optional_root.glob("codex-*"))
+        existing_vendor_roots = [item for item in vendor_roots if item.exists()]
         try:
-            if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
-                return True
+            for vendor_root in existing_vendor_roots:
+                if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
+                    return True
         except Exception:
             continue
     return False
@@ -370,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,
     *,
@@ -385,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 {}
@@ -689,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,
@@ -783,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"],
@@ -974,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)
@@ -985,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),
@@ -996,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),
@@ -1013,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"],
@@ -1023,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/client_sync.py

@@ -65,10 +65,9 @@ except Exception:
         }
 
     def resolve_client_runtime_profile(client: str, preferences: dict | None = None) -> dict:
-        _default_model = "claude-opus-4-7[1m]"
         defaults = {
-            "claude_code": {"model": _default_model, "reasoning_effort": ""},
-            "codex": {"model": _default_model, "reasoning_effort": ""},
+            "claude_code": {"model": "claude-opus-4-7[1m]", "reasoning_effort": "max"},
+            "codex": {"model": "gpt-5.5", "reasoning_effort": "xhigh"},
         }
         return dict(defaults.get(client, {}))
 
@@ -241,6 +240,15 @@ def _brain_bundle_root() -> Path:
     return Path(__file__).resolve().parents[1]
 
 
+def _codex_bundle_dir() -> Path:
+    explicit = str(os.environ.get("NEXO_CODEX_BUNDLE_DIR", "")).strip()
+    if explicit:
+        candidate = Path(explicit).expanduser()
+        if candidate.is_dir():
+            return candidate
+    return _brain_bundle_root() / "codex"
+
+
 def _platform_slug() -> str:
     if sys.platform.startswith("darwin"):
         os_part = "darwin"
@@ -379,12 +387,15 @@ def _codex_vendor_present(managed_prefix: Path) -> bool:
         managed_prefix / "node_modules" / "@openai" / "codex",
     ]
     for package_root in package_roots:
-        vendor_root = package_root / "vendor"
-        if not vendor_root.exists():
-            continue
+        vendor_roots = [package_root / "vendor"]
+        optional_root = package_root / "node_modules" / "@openai"
+        if optional_root.is_dir():
+            vendor_roots.extend(item / "vendor" for item in optional_root.glob("codex-*"))
+        existing_vendor_roots = [item for item in vendor_roots if item.exists()]
         try:
-            if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
-                return True
+            for vendor_root in existing_vendor_roots:
+                if any(candidate.is_file() for candidate in vendor_root.rglob("bin/codex*")):
+                    return True
         except Exception:
             continue
     return False
@@ -659,7 +670,7 @@ def ensure_codex_installed(*, user_home: str | os.PathLike[str] | None = None) -
     )
 
     desktop_node, bundled_npm_cli = _bundled_npm_runtime()
-    bundle_dir = _brain_bundle_root() / "codex"
+    bundle_dir = _codex_bundle_dir()
     if desktop_managed and not (desktop_node and bundled_npm_cli):
         vendor_installed = _install_codex_vendor_from_bundle(
             bundle_dir=bundle_dir,
@@ -946,7 +957,7 @@ def _sync_codex_managed_config(
     # Heal any pre-existing Claude model written by earlier NEXO versions.
     existing_model = str(payload.get("model") or "").strip()
     if existing_model and _looks_like_claude_model(existing_model):
-        payload["model"] = "gpt-5.4"
+        payload["model"] = "gpt-5.5"
 
     # Only write a model from the runtime profile into Codex config if it
     # looks like a Codex/OpenAI model. Claude models are invalid for Codex
@@ -956,7 +967,7 @@ def _sync_codex_managed_config(
         payload["model"] = profile_model
     elif profile_model:
         # Fall back to a known-good Codex default to self-heal.
-        payload["model"] = "gpt-5.4"
+        payload["model"] = "gpt-5.5"
     if "reasoning_effort" in runtime_profile:
         payload["model_reasoning_effort"] = runtime_profile.get("reasoning_effort") or ""
 

package/src/enforcement_classifier.py

@@ -121,7 +121,7 @@ def classify(
         context: Optional extra context appended to the user message.
         call_raw: Injection point for tests — defaults to call_model_raw.
         cache: TTL cache instance. Tests can pass a fresh cache.
-        tier: Resonance tier. Default "muy_bajo" (Haiku / gpt-5.4-mini).
+        tier: Resonance tier. Default "muy_bajo" (Haiku / gpt-5.5 low).
         tristate: When True, return "yes" / "no" / "unknown" as strings.
             "unknown" represents the conservative-parse-fallback path
             which existing bool callers cannot distinguish from a real

package/src/local_context/api.py

@@ -383,18 +383,22 @@ def _effective_file_type_rule(conn, extension: str) -> dict:
 
 
 def list_file_type_rules(*, readonly: bool = True) -> dict:
-    if not readonly:
+    def _list() -> dict:
+        if readonly:
+            conn = _read_conn()
+            try:
+                rows = _list_file_type_rules_conn(conn)
+            finally:
+                _close_read_conn(conn)
+            return _shape_file_type_rules(rows)
+
         conn = _conn()
         seed_core_file_type_rules(conn)
         conn.commit()
         rows = _list_file_type_rules_conn(conn)
-    else:
-        conn = _read_conn()
-        try:
-            rows = _list_file_type_rules_conn(conn)
-        finally:
-            _close_read_conn(conn)
-    return _shape_file_type_rules(rows)
+        return _shape_file_type_rules(rows)
+
+    return _with_sqlite_busy_retry(_list)
 
 
 def _purge_assets_by_extension(conn, extension: str) -> dict:
@@ -406,49 +410,58 @@ def _purge_assets_by_extension(conn, extension: str) -> dict:
 
 
 def set_file_type_rule(extension: str, *, action: str = "extract", source: str = "user", priority: int | None = None, reason: str = "user") -> dict:
-    conn = _conn()
-    ext = _normalize_extension(extension)
-    if not ext:
-        return {"ok": False, "error": "extension_required"}
-    normalized_action = _normalize_file_type_action(action)
-    source_value = _normalize_source(source)
-    priority_value = int(priority if priority is not None else (82 if normalized_action == "extract" else 20 if normalized_action == "metadata" else 0))
-    timestamp = now()
-    conn.execute(
-        """
-        INSERT INTO local_index_file_type_rules(extension, action, source, priority, reason, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(extension, source) DO UPDATE SET
-          action=excluded.action,
-          priority=excluded.priority,
-          reason=excluded.reason,
-          updated_at=excluded.updated_at
-        """,
-        (ext, normalized_action, source_value, priority_value, reason, timestamp, timestamp),
-    )
-    cleanup = _purge_assets_by_extension(conn, ext) if normalized_action == "ignore" and source_value == "user" else {"assets": 0}
-    conn.commit()
-    log_event("info", "file_type_rule_set", "Local memory file type rule set", extension=ext, action=normalized_action, source=source_value, cleanup=cleanup)
-    return {"ok": True, "extension": ext, "action": normalized_action, "source": source_value, "priority": priority_value, "cleanup": cleanup}
+    def _set() -> dict:
+        conn = _conn()
+        ext = _normalize_extension(extension)
+        if not ext:
+            return {"ok": False, "error": "extension_required"}
+        normalized_action = _normalize_file_type_action(action)
+        source_value = _normalize_source(source)
+        priority_value = int(priority if priority is not None else (82 if normalized_action == "extract" else 20 if normalized_action == "metadata" else 0))
+        timestamp = now()
+        conn.execute(
+            """
+            INSERT INTO local_index_file_type_rules(extension, action, source, priority, reason, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(extension, source) DO UPDATE SET
+              action=excluded.action,
+              priority=excluded.priority,
+              reason=excluded.reason,
+              updated_at=excluded.updated_at
+            """,
+            (ext, normalized_action, source_value, priority_value, reason, timestamp, timestamp),
+        )
+        cleanup = _purge_assets_by_extension(conn, ext) if normalized_action == "ignore" and source_value == "user" else {"assets": 0}
+        conn.commit()
+        log_event("info", "file_type_rule_set", "Local memory file type rule set", extension=ext, action=normalized_action, source=source_value, cleanup=cleanup)
+        return {"ok": True, "extension": ext, "action": normalized_action, "source": source_value, "priority": priority_value, "cleanup": cleanup}
+
+    return _with_sqlite_busy_retry(_set)
 
 
 def remove_file_type_rule(extension: str, *, source: str = "user") -> dict:
-    conn = _conn()
-    ext = _normalize_extension(extension)
-    source_value = _normalize_source(source)
-    conn.execute("DELETE FROM local_index_file_type_rules WHERE extension=? AND source=?", (ext, source_value))
-    conn.commit()
-    log_event("info", "file_type_rule_removed", "Local memory file type rule removed", extension=ext, source=source_value)
-    return {"ok": True, "extension": ext, "source": source_value}
+    def _remove() -> dict:
+        conn = _conn()
+        ext = _normalize_extension(extension)
+        source_value = _normalize_source(source)
+        conn.execute("DELETE FROM local_index_file_type_rules WHERE extension=? AND source=?", (ext, source_value))
+        conn.commit()
+        log_event("info", "file_type_rule_removed", "Local memory file type rule removed", extension=ext, source=source_value)
+        return {"ok": True, "extension": ext, "source": source_value}
+
+    return _with_sqlite_busy_retry(_remove)
 
 
 def reset_file_type_rules() -> dict:
-    conn = _conn()
-    deleted = int(conn.execute("DELETE FROM local_index_file_type_rules WHERE source='user'").rowcount or 0)
-    seeded = seed_core_file_type_rules(conn)
-    conn.commit()
-    log_event("info", "file_type_rules_reset", "Local memory user file type overrides reset", deleted=deleted)
-    return {"ok": True, "deleted": deleted, "core_rules": int(seeded.get("rules") or 0), "file_types": list_file_type_rules(readonly=False)}
+    def _reset() -> dict:
+        conn = _conn()
+        deleted = int(conn.execute("DELETE FROM local_index_file_type_rules WHERE source='user'").rowcount or 0)
+        seeded = seed_core_file_type_rules(conn)
+        conn.commit()
+        log_event("info", "file_type_rules_reset", "Local memory user file type overrides reset", deleted=deleted)
+        return {"ok": True, "deleted": deleted, "core_rules": int(seeded.get("rules") or 0), "file_types": list_file_type_rules(readonly=False)}
+
+    return _with_sqlite_busy_retry(_reset)
 
 
 def _file_type_action(conn, path: str | Path) -> str:

package/src/model_defaults.json

@@ -8,10 +8,10 @@
     "previous_defaults": ["claude-opus-4-6[1m]"]
   },
   "codex": {
-    "model": "gpt-5.4",
+    "model": "gpt-5.5",
     "reasoning_effort": "xhigh",
-    "display_name": "GPT-5.4 with max reasoning",
-    "recommendation_version": 1,
-    "previous_defaults": []
+    "display_name": "GPT-5.5 with max reasoning",
+    "recommendation_version": 2,
+    "previous_defaults": ["gpt-5.4"]
   }
 }

package/src/model_defaults.py

@@ -27,11 +27,11 @@ _FALLBACK: dict[str, Any] = {
         "previous_defaults": ["claude-opus-4-6[1m]"],
     },
     "codex": {
-        "model": "gpt-5.4",
+        "model": "gpt-5.5",
         "reasoning_effort": "xhigh",
-        "display_name": "GPT-5.4 with max reasoning",
-        "recommendation_version": 1,
-        "previous_defaults": [],
+        "display_name": "GPT-5.5 with max reasoning",
+        "recommendation_version": 2,
+        "previous_defaults": ["gpt-5.4"],
     },
 }
 

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/resonance_tiers.json

@@ -2,23 +2,23 @@
   "tiers": {
     "maximo": {
       "claude_code": { "model": "claude-opus-4-7[1m]", "effort": "max" },
-      "codex":       { "model": "gpt-5.4",             "effort": "xhigh" }
+      "codex":       { "model": "gpt-5.5",             "effort": "xhigh" }
     },
     "alto": {
       "claude_code": { "model": "claude-opus-4-7[1m]", "effort": "xhigh" },
-      "codex":       { "model": "gpt-5.4",             "effort": "high" }
+      "codex":       { "model": "gpt-5.5",             "effort": "high" }
     },
     "medio": {
       "claude_code": { "model": "claude-opus-4-7[1m]", "effort": "high" },
-      "codex":       { "model": "gpt-5.4",             "effort": "medium" }
+      "codex":       { "model": "gpt-5.5",             "effort": "medium" }
     },
     "bajo": {
       "claude_code": { "model": "claude-opus-4-7[1m]", "effort": "medium" },
-      "codex":       { "model": "gpt-5.4",             "effort": "low" }
+      "codex":       { "model": "gpt-5.5",             "effort": "low" }
     },
     "muy_bajo": {
       "claude_code": { "model": "claude-haiku-4-5-20251001", "effort": "" },
-      "codex":       { "model": "gpt-5.4-mini",              "effort": "low" }
+      "codex":       { "model": "gpt-5.5",                   "effort": "low" }
     }
   },
   "default_tier": "alto"

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/launchagents/README.md

@@ -37,7 +37,7 @@ Each plist calls `/usr/bin/python3`. If your Python 3 is elsewhere (e.g. Homebre
 
 ### 3. Create required directories
 
-The agents write logs to `{{NEXO_HOME}}/logs/` and `{{NEXO_HOME}}/coordination/`. Create them if they do not exist:
+The agents write logs to `{{NEXO_HOME}}/runtime/logs/` and `{{NEXO_HOME}}/coordination/`. Create them if they do not exist:
 
 ```bash
 mkdir -p "$NEXO_HOME/logs" "$NEXO_HOME/coordination"
@@ -117,7 +117,7 @@ These agents power NEXO's learning and memory systems. Strongly recommended.
 
 ## Logs
 
-All agents write stdout and stderr to files under `{{NEXO_HOME}}/logs/` (or `{{NEXO_HOME}}/coordination/` for the session-related ones). Check these first when debugging:
+All agents write stdout and stderr to files under `{{NEXO_HOME}}/runtime/logs/` (or `{{NEXO_HOME}}/coordination/` for the session-related ones). Check these first when debugging:
 
 ```bash
 tail -50 "$NEXO_HOME/logs/watchdog-stdout.log"

package/templates/launchagents/com.nexo.auto-close-sessions.plist

@@ -14,7 +14,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/auto_close_sessions.py</string>
+        <string>{{NEXO_HOME}}/core/auto_close_sessions.py</string>
     </array>
     <key>StartInterval</key>
     <integer>300</integer>

package/templates/launchagents/com.nexo.catchup.plist

@@ -14,16 +14,16 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-catchup.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-catchup.py</string>
     </array>
     <key>RunAtLoad</key>
     <true/>
     <key>StartInterval</key>
     <integer>900</integer>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/catchup-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/catchup-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/catchup-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/catchup-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>HOME</key>

package/templates/launchagents/com.nexo.cognitive-decay.plist

@@ -14,7 +14,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-cognitive-decay.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-cognitive-decay.py</string>
     </array>
     <key>StartCalendarInterval</key>
     <dict>
@@ -24,9 +24,9 @@
         <integer>0</integer>
     </dict>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/cognitive-decay-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/cognitive-decay-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/cognitive-decay-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/cognitive-decay-stderr.log</string>
     <key>RunAtLoad</key>
     <false/>
     <key>EnvironmentVariables</key>

package/templates/launchagents/com.nexo.deep-sleep.plist

@@ -15,7 +15,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/bin/bash</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-deep-sleep.sh</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-deep-sleep.sh</string>
     </array>
     <key>StartCalendarInterval</key>
     <dict>
@@ -25,9 +25,9 @@
         <integer>30</integer>
     </dict>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/deep-sleep-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/deep-sleep-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/deep-sleep-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/deep-sleep-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>PATH</key>

package/templates/launchagents/com.nexo.evolution.plist

@@ -14,7 +14,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-evolution-run.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-evolution-run.py</string>
     </array>
     <key>StartCalendarInterval</key>
     <dict>
@@ -26,9 +26,9 @@
         <integer>0</integer>
     </dict>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/evolution-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/evolution-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/evolution-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/evolution-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>HOME</key>

package/templates/launchagents/com.nexo.followup-hygiene.plist

@@ -15,7 +15,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-followup-hygiene.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-followup-hygiene.py</string>
     </array>
     <key>StartCalendarInterval</key>
     <dict>
@@ -27,9 +27,9 @@
         <integer>0</integer>
     </dict>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/followup-hygiene-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/followup-hygiene-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/followup-hygiene-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/followup-hygiene-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>HOME</key>

package/templates/launchagents/com.nexo.immune.plist

@@ -14,7 +14,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-immune.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-immune.py</string>
     </array>
 
     <key>StartInterval</key>

package/templates/launchagents/com.nexo.postmortem.plist

@@ -15,7 +15,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-postmortem-consolidator.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-postmortem-consolidator.py</string>
     </array>
     <key>RunAtLoad</key>
     <false/>
@@ -27,9 +27,9 @@
         <integer>30</integer>
     </dict>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/postmortem-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/postmortem-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/postmortem-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/postmortem-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>HOME</key>

package/templates/launchagents/com.nexo.self-audit.plist

@@ -15,7 +15,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-daily-self-audit.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-daily-self-audit.py</string>
     </array>
 
     <key>StartCalendarInterval</key>
@@ -27,10 +27,10 @@
     </dict>
 
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/self-audit-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/self-audit-stdout.log</string>
 
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/self-audit-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/self-audit-stderr.log</string>
 
     <key>EnvironmentVariables</key>
     <dict>

package/templates/launchagents/com.nexo.synthesis.plist

@@ -15,7 +15,7 @@
     <key>ProgramArguments</key>
     <array>
         <string>/usr/bin/python3</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-synthesis.py</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-synthesis.py</string>
     </array>
 
     <key>StartCalendarInterval</key>

package/templates/launchagents/com.nexo.watchdog.plist

@@ -14,16 +14,16 @@
     <key>ProgramArguments</key>
     <array>
         <string>/bin/bash</string>
-        <string>{{NEXO_HOME}}/scripts/nexo-watchdog.sh</string>
+        <string>{{NEXO_HOME}}/core/scripts/nexo-watchdog.sh</string>
     </array>
     <key>StartInterval</key>
     <integer>1800</integer>
     <key>RunAtLoad</key>
     <true/>
     <key>StandardOutPath</key>
-    <string>{{NEXO_HOME}}/logs/watchdog-stdout.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/watchdog-stdout.log</string>
     <key>StandardErrorPath</key>
-    <string>{{NEXO_HOME}}/logs/watchdog-stderr.log</string>
+    <string>{{NEXO_HOME}}/runtime/logs/watchdog-stderr.log</string>
     <key>EnvironmentVariables</key>
     <dict>
         <key>PATH</key>

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: