nexo-brain 5.10.0 → 5.10.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.10.0",
+  "version": "5.10.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 `5.10.0` is the current packaged-runtime line: fixes the deep-sleep extract bloat that made Session 1 take ~57 minutes on some installs (new `bare_mode` on `run_automation_prompt` wires `claude --bare` for JSON-only extractor callers — ~4.3× faster per child, sourced from `ANTHROPIC_API_KEY` env or `~/.claude/anthropic-api-key.txt`). `caller=` is now **mandatory** on `run_automation_prompt` — no silent fallback; every automation subprocess traces back to a registered caller with a deliberate tier. Five personal scripts (`personal/email-monitor`, `personal/github-monitor`, `personal/post-x`, `personal/followup-runner`, `personal/orchestrator-v2`) joined the resonance map with tiers picked per caller based on what each one does. gbp/* marketing posts bumped from `medio` to `alto` (public-facing copy, quality first over speed). 65 legacy protocol debts bulk-resolved as part of the audit — the patterns that generated them are structurally closed by mandatory `caller=` + unified session log + bare_mode.
+Version `5.10.2` is the current packaged-runtime line: auto-bootstraps `brain/profile.json` from `brain/calibration.json` on `nexo update` when the profile file is missing, empty, or corrupt AND calibration carries at least one of `meta.role`, `meta.technical_level`, `name`, `language`. NEXO Desktop's *Preferencias → Avanzado* tab used to render an empty `{}` for that block when the onboarding flow had been interrupted; now it either shows the seeded profile or a friendly explanation of what each file is for, paired with Desktop `v0.11.2` which adds header descriptions to both JSON blocks. Never overwrites a populated profile, never raises, idempotent. Also fixes a latent host-filesystem leak in `test_user_facing_caller_with_no_user_default_uses_alto` exposed by the v5.10.1 migration.
+
+Previously in `5.10.1`: silent, one-shot migration that recovers legacy `reasoning_effort="max"` (written by `nexo preferences --reasoning-effort max` before v5.9.0) into the new `preferences.default_resonance` map — any user who had configured `max` before v5.9.0 and never touched the new selector was silently falling back to `DEFAULT_RESONANCE="alto"` on interactive calls since the v5.10.0 update. `_run_runtime_post_sync()` runs `_migrate_effort_to_resonance()` exactly once: `max→maximo`, `xhigh→alto`, `high→medio`, `medium→bajo`. No-op when calibration or schedule already declares an explicit `default_resonance`; idempotent; conservative; never raises.
+
+Previously in `5.10.0`: fixes the deep-sleep extract bloat that made Session 1 take ~57 minutes on some installs (new `bare_mode` on `run_automation_prompt` wires `claude --bare` for JSON-only extractor callers — ~4.3× faster per child, sourced from `ANTHROPIC_API_KEY` env or `~/.claude/anthropic-api-key.txt`). `caller=` is now **mandatory** on `run_automation_prompt` — no silent fallback; every automation subprocess traces back to a registered caller with a deliberate tier. Five personal scripts (`personal/email-monitor`, `personal/github-monitor`, `personal/post-x`, `personal/followup-runner`, `personal/orchestrator-v2`) joined the resonance map with tiers picked per caller based on what each one does. gbp/* marketing posts bumped from `medio` to `alto` (public-facing copy, quality first over speed). 65 legacy protocol debts bulk-resolved as part of the audit — the patterns that generated them are structurally closed by mandatory `caller=` + unified session log + bare_mode.
 
 Previously in `5.9.1`: 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`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.10.0",
+  "version": "5.10.2",
   "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/auto_update.py

@@ -875,6 +875,182 @@ def _purge_zero_byte_db_files() -> list[Path]:
     return removed
 
 
+def _migrate_effort_to_resonance(dest: Path = NEXO_HOME) -> list[str]:
+    """Auto-migrate legacy ``reasoning_effort`` preference into the new
+    ``preferences.default_resonance`` knob.
+
+    Context: before v5.9.0 the user's power-level preference lived in
+    ``config/schedule.json`` under
+    ``client_runtime_profiles.claude_code.reasoning_effort`` — one of
+    ``max`` / ``xhigh`` / ``high`` / ``medium``. v5.9.0 introduced the
+    resonance map, with ``preferences.default_resonance`` (one of
+    ``maximo`` / ``alto`` / ``medio`` / ``bajo``) written to
+    ``brain/calibration.json``. When the new code path kicks in, a user
+    whose only recorded preference is the legacy effort silently falls
+    back to ``DEFAULT_RESONANCE`` (``alto``), losing their prior
+    preference. v5.10.0 shipped without a migration for this; v5.10.1
+    adds it here.
+
+    The migration is idempotent and conservative: it only runs when the
+    user has NOT set ``default_resonance`` explicitly anywhere (neither
+    in ``calibration.json`` nor in ``schedule.json``). That means users
+    who already adjusted their preference through the Desktop UI or the
+    ``nexo preferences --resonance`` CLI keep whatever they chose; this
+    migration only recovers the legacy preference for users who never
+    touched either.
+
+    Mapping (mirrors ``_RESONANCE_TABLE`` in ``src/resonance_map.py``):
+        max    → maximo
+        xhigh  → alto
+        high   → medio
+        medium → bajo
+
+    Returns the list of actions taken for logging. Failures are
+    swallowed: migration must never block an update.
+    """
+    import json as _json
+
+    actions: list[str] = []
+
+    cal_path = dest / "brain" / "calibration.json"
+    sched_path = dest / "config" / "schedule.json"
+
+    try:
+        cal = _json.loads(cal_path.read_text()) if cal_path.exists() else {}
+        if not isinstance(cal, dict):
+            cal = {}
+    except Exception:
+        cal = {}
+
+    try:
+        sched = _json.loads(sched_path.read_text()) if sched_path.exists() else {}
+        if not isinstance(sched, dict):
+            sched = {}
+    except Exception:
+        sched = {}
+
+    existing_cal_pref = ""
+    if isinstance(cal.get("preferences"), dict):
+        existing_cal_pref = str(cal["preferences"].get("default_resonance") or "").strip().lower()
+    existing_sched_pref = str(sched.get("default_resonance") or "").strip().lower()
+
+    valid_tiers = {"maximo", "alto", "medio", "bajo"}
+    if existing_cal_pref in valid_tiers or existing_sched_pref in valid_tiers:
+        return actions  # user already has an explicit resonance preference
+
+    # Look up the legacy effort hint.
+    effort = ""
+    profiles = sched.get("client_runtime_profiles")
+    if isinstance(profiles, dict):
+        cc = profiles.get("claude_code") if isinstance(profiles.get("claude_code"), dict) else {}
+        effort = str(cc.get("reasoning_effort") or "").strip().lower()
+
+    legacy_map = {
+        "max": "maximo",
+        "xhigh": "alto",
+        "high": "medio",
+        "medium": "bajo",
+    }
+    target_tier = legacy_map.get(effort)
+    if not target_tier:
+        return actions  # nothing usable to migrate from
+
+    # Write into calibration.json (canonical location for v5.9.1+).
+    try:
+        cal_path.parent.mkdir(parents=True, exist_ok=True)
+        prefs = cal.get("preferences")
+        if not isinstance(prefs, dict):
+            prefs = {}
+        prefs["default_resonance"] = target_tier
+        cal["preferences"] = prefs
+        cal_path.write_text(_json.dumps(cal, indent=2, ensure_ascii=False) + "\n")
+        actions.append(
+            f"resonance-migration:{effort}->{target_tier}"
+        )
+    except Exception as exc:
+        actions.append(f"resonance-migration-warning:{exc.__class__.__name__}")
+
+    return actions
+
+
+def _bootstrap_profile_from_calibration_meta(dest: Path = NEXO_HOME) -> list[str]:
+    """Create ``brain/profile.json`` from ``calibration.json`` fields when the
+    profile file does not exist yet.
+
+    Context: the onboarding flow documented in CLAUDE.md writes ``role`` and
+    ``technical_level`` to ``brain/profile.json``. Users who went through the
+    2025/early-2026 flow (or whose onboarding was interrupted) ended up with
+    those values living under ``calibration.json → meta.role`` and
+    ``meta.technical_level`` only, with no ``profile.json`` file at all.
+    NEXO Desktop's "Preferencias → Avanzado" tab then shows an empty
+    ``{}`` for ``profile.json`` with no context — confusing for the operator.
+
+    This migration is conservative and idempotent:
+    - Only runs when ``profile.json`` does not exist (or is empty/invalid).
+    - Only writes when ``calibration.json`` has at least one of
+      ``meta.role`` / ``meta.technical_level`` / ``name`` / ``language``.
+    - Never overwrites an existing profile.
+    - Errors are swallowed into a ``profile-bootstrap-warning:*`` action
+      line; the update path never raises.
+    """
+    import json as _json
+
+    actions: list[str] = []
+
+    cal_path = dest / "brain" / "calibration.json"
+    profile_path = dest / "brain" / "profile.json"
+
+    if profile_path.exists():
+        try:
+            existing = _json.loads(profile_path.read_text())
+            if isinstance(existing, dict) and existing:
+                return actions  # profile already populated, keep untouched
+        except Exception:
+            # Corrupt / empty file — fall through and rewrite below.
+            pass
+
+    if not cal_path.exists():
+        return actions
+
+    try:
+        cal = _json.loads(cal_path.read_text())
+        if not isinstance(cal, dict):
+            return actions
+    except Exception:
+        return actions
+
+    meta = cal.get("meta") if isinstance(cal.get("meta"), dict) else {}
+    payload: dict = {}
+
+    role = str(meta.get("role") or "").strip()
+    tech = str(meta.get("technical_level") or "").strip()
+    name = str(cal.get("name") or "").strip()
+    lang = str(cal.get("language") or "").strip()
+
+    if role:
+        payload["role"] = role
+    if tech:
+        payload["technical_level"] = tech
+    if name:
+        payload["name"] = name
+    if lang:
+        payload["language"] = lang
+
+    if not payload:
+        return actions  # nothing to seed the profile with
+
+    payload["source"] = "auto_update._bootstrap_profile_from_calibration_meta"
+
+    try:
+        profile_path.parent.mkdir(parents=True, exist_ok=True)
+        profile_path.write_text(_json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+        actions.append(f"profile-bootstrap:{len(payload)-1}-fields")
+    except Exception as exc:
+        actions.append(f"profile-bootstrap-warning:{exc.__class__.__name__}")
+
+    return actions
+
+
 def _heal_deep_sleep_runtime(dest: Path = NEXO_HOME) -> list[str]:
     """Repair deep-sleep state that older runtimes left in a bad shape.
 
@@ -2697,6 +2873,27 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     except Exception as exc:
         actions.append(f"deep-sleep-heal-warning:{exc.__class__.__name__}")
 
+    # Recover the user's legacy reasoning_effort preference into the new
+    # default_resonance knob. v5.10.0 left this gap — users who had
+    # `reasoning_effort="max"` in schedule.json silently degraded to
+    # DEFAULT_RESONANCE=alto when the resonance map took over. This
+    # migration restores their choice exactly once.
+    try:
+        _emit_progress(progress_fn, "Migrating legacy effort preference to resonance...")
+        mig_actions = _migrate_effort_to_resonance(dest)
+        for action in mig_actions:
+            actions.append(action)
+    except Exception as exc:
+        actions.append(f"resonance-migration-warning:{exc.__class__.__name__}")
+
+    try:
+        _emit_progress(progress_fn, "Bootstrapping profile.json from calibration...")
+        boot_actions = _bootstrap_profile_from_calibration_meta(dest)
+        for action in boot_actions:
+            actions.append(action)
+    except Exception as exc:
+        actions.append(f"profile-bootstrap-warning:{exc.__class__.__name__}")
+
     _emit_progress(progress_fn, "Verifying runtime imports...")
     verify = subprocess.run(
         [sys.executable, "-c", "import server"],