nexo-brain 5.9.0 → 5.9.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.9.0",
+  "version": "5.9.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,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 `5.9.0` is the current packaged-runtime line: every Claude/Codex invocation now flows through a central **resonance map** and a **unified session log**. Four tiers (`MAXIMO` / `ALTO` / `MEDIO` / `BAJO`) each resolve to a concrete `(model, reasoning_effort)` pair per backend. User-facing callers (`nexo chat`, Desktop new conversation, interactive `nexo update`) honour the user's `default_resonance` preference; system-owned callers (deep-sleep, evolution, catchup, GBP posts, …) run at a fixed tier chosen per caller in `src/resonance_map.py` — the user's preference never downgrades a cron we decided needs `MAXIMO`. Unknown callers raise `UnregisteredCallerError`. Migration #41 adds `caller`, `session_type`, `started_at`, `ended_at`, `pid`, `resonance_tier` to `automation_runs`; interactive sessions record a row at spawn (with `ended_at=NULL`) and update it on close, so the Brain now has a single source of truth for every Claude/Codex call regardless of origin. New `nexo preferences --resonance` CLI. New MCP tools `nexo_session_log_create` / `nexo_session_log_close` let NEXO Desktop (which spawns `claude` directly from its TypeScript process) feed the same log.
+Version `5.9.1` is the current packaged-runtime line: adds `default_resonance` to `brain/calibration.json` via the Desktop-facing schema (`nexo schema --json`), so NEXO Desktop's Preferences dialog renders a select with `Máximo` / `Alto (recomendado)` / `Medio` / `Bajo` automatically — no Desktop release needed. `resolve_tier_for_caller` reads calibration first and falls back to the legacy `schedule.json` location. `nexo preferences --resonance` writes both. The UI control only affects interactive sessions (`nexo chat`, Desktop new conversation, interactive `nexo update`); crons and background processes stay pinned per caller in `resonance_map.py`.
+
+Previously in `5.9.0`: every Claude/Codex invocation now flows through a central **resonance map** and a **unified session log**. Four tiers (`MAXIMO` / `ALTO` / `MEDIO` / `BAJO`) each resolve to a concrete `(model, reasoning_effort)` pair per backend. User-facing callers (`nexo chat`, Desktop new conversation, interactive `nexo update`) honour the user's `default_resonance` preference; system-owned callers (deep-sleep, evolution, catchup, GBP posts, …) run at a fixed tier chosen per caller in `src/resonance_map.py` — the user's preference never downgrades a cron we decided needs `MAXIMO`. Unknown callers raise `UnregisteredCallerError`. Migration #41 adds `caller`, `session_type`, `started_at`, `ended_at`, `pid`, `resonance_tier` to `automation_runs`; interactive sessions record a row at spawn (with `ended_at=NULL`) and update it on close, so the Brain now has a single source of truth for every Claude/Codex call regardless of origin. New `nexo preferences --resonance` CLI. New MCP tools `nexo_session_log_create` / `nexo_session_log_close` let NEXO Desktop (which spawns `claude` directly from its TypeScript process) feed the same log.
 
 Previously in `5.8.2`: the Brain core no longer auto-classifies `followups` and `reminders` on behalf of agents. v5.8.0's `classify_task()` heuristic (NEXO-specific ID prefixes `NF-PROTOCOL-*` / `NF-DS-*` / `NF-AUDIT-*`, Spanish user-verbs `debes` / `revisar` / `firmar`, agent keywords `monitor` / `auditoría diaria` / `checkpoint`) was fine for NEXO's own DB but bled convention into every third-party agent plugged into the shared Brain. The core now persists `internal=0` and `owner=NULL` when the caller omits them, and clients that want automatic classification (NEXO Desktop does, via its `_legacyClassifyOwner` helpers) compute it themselves and pass the result. Migration #40 keeps the columns + indexes; rows already backfilled by v5.8.0 keep their values. `normalise_owner` still explicitly rejects the string `"nexo"` so legacy hardcoding cannot sneak back in.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.9.0",
+  "version": "5.9.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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

@@ -1099,6 +1099,34 @@ def _clients_sync(args):
     return 0 if result.get("ok") else 1
 
 
+def _write_calibration_default_resonance(tier: str) -> None:
+    """Persist ``preferences.default_resonance`` in ``brain/calibration.json``.
+
+    NEXO Desktop's preferences UI reads from calibration.json (matches the
+    rest of the user-facing knobs — autonomy, communication, assistant_name,
+    …). This helper keeps the CLI path writing to both calibration.json
+    AND schedule.json so the two surfaces never disagree.
+    """
+    cal_path = NEXO_HOME / "brain" / "calibration.json"
+    try:
+        cal_path.parent.mkdir(parents=True, exist_ok=True)
+        if cal_path.exists():
+            data = json.loads(cal_path.read_text())
+            if not isinstance(data, dict):
+                data = {}
+        else:
+            data = {}
+        prefs = data.get("preferences")
+        if not isinstance(prefs, dict):
+            prefs = {}
+        prefs["default_resonance"] = tier
+        data["preferences"] = prefs
+        cal_path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    except Exception as exc:  # best-effort; schedule.json still has the value
+        print(f"[NEXO] Warning: could not update calibration.json: {exc}",
+              file=sys.stderr)
+
+
 def _preferences(args):
     """Read or change user preferences stored in schedule.json.
 
@@ -1110,7 +1138,11 @@ def _preferences(args):
         load_client_preferences,
         save_client_preferences,
     )
-    from resonance_map import DEFAULT_RESONANCE, TIERS
+    from resonance_map import (
+        DEFAULT_RESONANCE,
+        TIERS,
+        _load_user_default_resonance,
+    )
 
     prefs = load_client_preferences()
     if not isinstance(prefs, dict):
@@ -1125,26 +1157,37 @@ def _preferences(args):
                 file=sys.stderr,
             )
             return 2
+        # Write to schedule.json (legacy CLI location)…
         save_client_preferences(default_resonance=tier)
+        # …and to calibration.json (where NEXO Desktop's preferences UI
+        # reads/writes). Keeping both in sync means the two surfaces agree.
+        _write_calibration_default_resonance(tier)
         prefs = load_client_preferences()
 
-    current_resonance = str(
+    calibration_value = _load_user_default_resonance()
+    schedule_value = str(
         (prefs.get("default_resonance") if isinstance(prefs, dict) else "")
-        or DEFAULT_RESONANCE
-    )
+        or ""
+    ).strip().lower()
+    current_resonance = calibration_value or schedule_value or DEFAULT_RESONANCE
 
     if args.show or args.resonance:
+        is_explicit = bool(calibration_value or schedule_value)
         payload = {
             "default_resonance": current_resonance,
-            "default_resonance_is_explicit": isinstance(prefs, dict)
-                and bool(prefs.get("default_resonance")),
+            "default_resonance_is_explicit": is_explicit,
+            "default_resonance_source": (
+                "calibration.json" if calibration_value
+                else ("schedule.json" if schedule_value else "default")
+            ),
             "available_tiers": list(TIERS),
         }
         if args.json:
             print(json.dumps(payload, indent=2, ensure_ascii=False))
         else:
             print(f"default_resonance = {current_resonance}")
-            if not payload["default_resonance_is_explicit"]:
+            print(f"  source: {payload['default_resonance_source']}")
+            if not is_explicit:
                 print(f"  (inherited from DEFAULT_RESONANCE; run "
                       f"`nexo preferences --resonance alto` to set explicitly)")
         return 0

package/src/desktop_bridge.py

@@ -191,6 +191,34 @@ def _schema_fields() -> list[dict]:
                 {"value": "verbose", "label": {"es": "Detallado", "en": "Verbose"}},
             ],
         },
+        {
+            "path": "preferences.default_resonance",
+            "file": "calibration.json",
+            "label": {"es": "Resonancia por defecto", "en": "Default resonance"},
+            "type": "select",
+            "group": "preferences",
+            "default": "alto",
+            "hint": {
+                "es": (
+                    "Potencia del modelo para sesiones interactivas (nexo chat y "
+                    "nueva conversación en Desktop). Los crons y procesos de fondo "
+                    "(deep sleep, evolution, etc.) ignoran esta preferencia — los "
+                    "definimos nosotros en resonance_map.py por calidad."
+                ),
+                "en": (
+                    "Model power for interactive sessions (nexo chat and Desktop "
+                    "new conversation). Crons and background processes (deep sleep, "
+                    "evolution, etc.) ignore this preference — we pin them per "
+                    "caller in resonance_map.py based on quality needs."
+                ),
+            },
+            "options": [
+                {"value": "maximo", "label": {"es": "Máximo", "en": "Maximum"}},
+                {"value": "alto", "label": {"es": "Alto (recomendado)", "en": "High (recommended)"}},
+                {"value": "medio", "label": {"es": "Medio", "en": "Medium"}},
+                {"value": "bajo", "label": {"es": "Bajo", "en": "Low"}},
+            ],
+        },
         {
             "path": "meta.role",
             "file": "calibration.json",

package/src/resonance_map.py

@@ -174,6 +174,48 @@ class UnregisteredCallerError(ValueError):
 # Resolution
 # ---------------------------------------------------------------------------
 
+def _load_user_default_resonance() -> str:
+    """Resolve the user's ``default_resonance`` preference.
+
+    Reads ``calibration.json`` first (``preferences.default_resonance``, the
+    location NEXO Desktop's preferences UI writes to) and falls back to
+    ``schedule.json`` (``default_resonance``, the location the CLI used to
+    write to in v5.9.0). Returns an empty string if neither source has a
+    valid tier — callers should treat empty as "no preference".
+    """
+    import json as _json
+    import os as _os
+    from pathlib import Path as _Path
+
+    home = _Path(_os.environ.get("NEXO_HOME", str(_Path.home() / ".nexo")))
+
+    # calibration.json (Desktop UI writes here)
+    cal_path = home / "brain" / "calibration.json"
+    try:
+        if cal_path.exists():
+            cal = _json.loads(cal_path.read_text())
+            prefs = cal.get("preferences") if isinstance(cal, dict) else None
+            if isinstance(prefs, dict):
+                tier = str(prefs.get("default_resonance") or "").strip().lower()
+                if tier in TIERS:
+                    return tier
+    except (OSError, _json.JSONDecodeError):
+        pass
+
+    # schedule.json (CLI legacy)
+    sched_path = home / "config" / "schedule.json"
+    try:
+        if sched_path.exists():
+            sched = _json.loads(sched_path.read_text())
+            tier = str((sched or {}).get("default_resonance") or "").strip().lower()
+            if tier in TIERS:
+                return tier
+    except (OSError, _json.JSONDecodeError):
+        pass
+
+    return ""
+
+
 def resolve_tier_for_caller(caller: str, user_default: str | None = None) -> str:
     """Return the resonance tier that should apply to ``caller``.
 
@@ -181,6 +223,9 @@ def resolve_tier_for_caller(caller: str, user_default: str | None = None) -> str
       if the user has no preference recorded).
     - System-owned callers resolve to their fixed tier.
     - Unknown callers raise ``UnregisteredCallerError``.
+
+    When ``user_default`` is not passed, the function looks it up from the
+    calibration.json preferences first and schedule.json second.
     """
     if not caller:
         raise UnregisteredCallerError(
@@ -188,7 +233,10 @@ def resolve_tier_for_caller(caller: str, user_default: str | None = None) -> str
             "in src/resonance_map.py so its reasoning budget is deliberate."
         )
     if caller in USER_FACING_CALLERS:
-        tier = (user_default or DEFAULT_RESONANCE).strip().lower()
+        resolved_default = user_default
+        if resolved_default is None:
+            resolved_default = _load_user_default_resonance()
+        tier = (resolved_default or DEFAULT_RESONANCE).strip().lower()
         if tier not in TIERS:
             tier = DEFAULT_RESONANCE
         return tier