nexo-brain 7.9.5 → 7.9.7

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.4",
+  "version": "7.9.7",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.9.5` is the current packaged-runtime line. Patch release that fixes canonical diary confirmation for Desktop: Brain now resolves the Desktop/Claude session UUID through NEXO SID aliases before checking `session_diary`, so archive/delete/app-exit can confirm diaries written by `nexo_session_diary_write` under the active `nexo-...` SID. Verification: `pytest tests/test_lifecycle_events.py` (28 passing) plus coordinated Desktop v0.28.4 shutdown/archive/delete checks.
+Version `7.9.7` is the current packaged-runtime line. Patch release that hardens the installed-user MCP/update path after live Desktop validation: Brain now normalizes managed runtime configs back to the stable `~/.nexo/core` root instead of leaving clients pinned to versioned snapshots, mirrors Claude Code MCP config into `~/.claude/mcp-cortex.json`, stamps the active MCP client in generated configs, and disables the FastMCP wrapped `output_schema` that was making Claude Code reject plain-text `nexo_*` tool results. Coordinated Desktop v0.28.8 consumes the same contract so archive/reopen/app-quit flows recover cleanly without reviving stale sessions.
+
+Previously in `7.9.5`: patch release that fixes canonical diary confirmation for Desktop: Brain resolves the Desktop/Claude session UUID through NEXO SID aliases before checking `session_diary`, so archive/delete/app-exit can confirm diaries written by `nexo_session_diary_write` under the active `nexo-...` SID. Verification: `pytest tests/test_lifecycle_events.py` (28 passing) plus coordinated Desktop v0.28.6 shutdown/archive/delete/app-exit checks.
 
 Previously in `7.9.4`: patch release that blocks the Brain 7.9.3 + Desktop 0.28.2 diary regression: canonical lifecycle plans now require real `session_diary` evidence (`wait_for_diary_write`) before `stop_session`, and canonical completion is rejected/retryable without that diary row. It also fixes npm CLI onboarding so `nexo-brain --version` and subcommands never launch the wizard when legacy/v2 calibration is already valid, commits setup calibration atomically only after the wizard completes, and adds `nexo-brain warmup-models` so install/update paths predownload the local mDeBERTa/BGE/reranker models. Verification: full Brain pytest (`2189 passed, 3 skipped, 1 xfailed, 5 xpassed`), release-readiness, npm pack dry-run, and coordinated Desktop v0.28.3 checks.
 

package/bin/nexo-brain.js

@@ -3249,6 +3249,10 @@ async function runSetup() {
     '    printf \'%s\\n\' "${NEXO_CODE%/}"',
     '    return 0',
     '  fi',
+    '  if [ -f "$NEXO_HOME/core/current/cli.py" ]; then',
+    '    printf \'%s\\n\' "$NEXO_HOME/core/current"',
+    '    return 0',
+    '  fi',
     '  if [ -f "$NEXO_HOME/core/cli.py" ]; then',
     '    printf \'%s\\n\' "$NEXO_HOME/core"',
     '    return 0',
@@ -3302,6 +3306,11 @@ async function runSetup() {
     '  exit 1',
     'fi',
     'CLI_PY="$NEXO_CODE/cli.py"',
+    'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/current/cli.py" ]; then',
+    '  NEXO_CODE="$NEXO_HOME/core/current"',
+    '  export NEXO_CODE',
+    '  CLI_PY="$NEXO_HOME/core/current/cli.py"',
+    'fi',
     'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/cli.py" ]; then',
     '  NEXO_CODE="$NEXO_HOME/core"',
     '  export NEXO_CODE',

package/package.json

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

@@ -537,6 +537,10 @@ def _runtime_cli_wrapper_text() -> str:
         '    printf \'%s\\n\' "${NEXO_CODE%/}"\n'
         '    return 0\n'
         '  fi\n'
+        '  if [ -f "$NEXO_HOME/core/current/cli.py" ]; then\n'
+        '    printf \'%s\\n\' "$NEXO_HOME/core/current"\n'
+        '    return 0\n'
+        '  fi\n'
         '  if [ -f "$NEXO_HOME/core/cli.py" ]; then\n'
         '    printf \'%s\\n\' "$NEXO_HOME/core"\n'
         '    return 0\n'
@@ -590,6 +594,11 @@ def _runtime_cli_wrapper_text() -> str:
         '  exit 1\n'
         'fi\n'
         'CLI_PY="$NEXO_CODE/cli.py"\n'
+        'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/current/cli.py" ]; then\n'
+        '  NEXO_CODE="$NEXO_HOME/core/current"\n'
+        '  export NEXO_CODE\n'
+        '  CLI_PY="$NEXO_HOME/core/current/cli.py"\n'
+        'fi\n'
         'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/cli.py" ]; then\n'
         '  NEXO_CODE="$NEXO_HOME/core"\n'
         '  export NEXO_CODE\n'
@@ -2253,19 +2262,20 @@ def _maybe_backfill_task_owner() -> None:
 
 
 def _f06_legacy_shim_map() -> list[tuple[str, Path]]:
+    core_root = NEXO_HOME / "core"
     return [
-        ("scripts", NEXO_HOME / "core" / "scripts"),
-        ("skills-core", paths.core_skills_dir(allow_legacy_fallback=False)),
-        ("db", paths.core_db_dir(allow_legacy_fallback=False)),
-        ("cognitive", paths.core_cognitive_dir(allow_legacy_fallback=False)),
-        ("doctor", paths.core_doctor_dir(allow_legacy_fallback=False)),
-        ("dashboard", paths.core_dashboard_dir(allow_legacy_fallback=False)),
+        ("scripts", core_root / "scripts"),
+        ("skills-core", core_root / "skills"),
+        ("db", core_root / "db"),
+        ("cognitive", core_root / "cognitive"),
+        ("doctor", core_root / "doctor"),
+        ("dashboard", core_root / "dashboard"),
         ("brain", NEXO_HOME / "personal" / "brain"),
         ("config", NEXO_HOME / "personal" / "config"),
         ("skills", NEXO_HOME / "personal" / "skills"),
-        ("plugins", NEXO_HOME / "core" / "plugins"),
-        ("hooks", NEXO_HOME / "core" / "hooks"),
-        ("rules", NEXO_HOME / "core" / "rules"),
+        ("plugins", core_root / "plugins"),
+        ("hooks", core_root / "hooks"),
+        ("rules", core_root / "rules"),
         ("data", NEXO_HOME / "runtime" / "data"),
         ("logs", NEXO_HOME / "runtime" / "logs"),
         ("operations", NEXO_HOME / "runtime" / "operations"),
@@ -2291,7 +2301,7 @@ def _f06_legacy_file_shim_map() -> list[tuple[str, Path]]:
 def _f06_packaged_code_file_targets() -> list[tuple[str, Path]]:
     names = list(_discover_runtime_root_python_modules(NEXO_HOME))
     names.extend(_discover_runtime_root_python_modules(NEXO_HOME / "core"))
-    for extra in ("requirements.txt", "model_defaults.json"):
+    for extra in ("requirements.txt", "model_defaults.json", "package.json", "version.json"):
         candidate = NEXO_HOME / extra
         canonical_candidate = NEXO_HOME / "core" / extra
         if candidate.exists() or canonical_candidate.exists():
@@ -2413,12 +2423,13 @@ def _promote_packaged_runtime_code_to_core() -> None:
             return resolved
         return path
 
+    core_root = NEXO_HOME / "core"
     dir_targets = [
-        ("db", paths.core_db_dir(allow_legacy_fallback=False)),
-        ("cognitive", paths.core_cognitive_dir(allow_legacy_fallback=False)),
-        ("doctor", paths.core_doctor_dir(allow_legacy_fallback=False)),
-        ("dashboard", paths.core_dashboard_dir(allow_legacy_fallback=False)),
-        ("skills-core", paths.core_skills_dir(allow_legacy_fallback=False)),
+        ("db", core_root / "db"),
+        ("cognitive", core_root / "cognitive"),
+        ("doctor", core_root / "doctor"),
+        ("dashboard", core_root / "dashboard"),
+        ("skills-core", core_root / "skills"),
     ]
 
     for legacy_name, canonical in dir_targets:
@@ -2895,11 +2906,11 @@ def _maybe_migrate_to_f06_layout() -> None:
             ("state", NEXO_HOME / "runtime" / "state"),
             ("backups", NEXO_HOME / "runtime" / "backups"),
             ("memory", NEXO_HOME / "runtime" / "memory"),
-            ("cognitive", paths.core_cognitive_dir(allow_legacy_fallback=False)),
+            ("cognitive", NEXO_HOME / "core" / "cognitive"),
             ("coordination", NEXO_HOME / "runtime" / "coordination"),
             ("exports", NEXO_HOME / "runtime" / "exports"),
             ("nexo-email", NEXO_HOME / "runtime" / "nexo-email"),
-            ("doctor", paths.core_doctor_dir(allow_legacy_fallback=False)),
+            ("doctor", NEXO_HOME / "core" / "doctor"),
             ("snapshots", NEXO_HOME / "runtime" / "snapshots"),
             ("crons", NEXO_HOME / "runtime" / "crons"),
             ("skills", NEXO_HOME / "personal" / "skills"),
@@ -3946,19 +3957,19 @@ def _resolve_sync_source() -> tuple[Path | None, Path | None]:
     dest = NEXO_HOME
 
     def _runtime_version_source() -> Path | None:
-        version_file = NEXO_HOME / "version.json"
-        if not version_file.is_file():
-            return None
-        try:
-            data = json.loads(version_file.read_text())
-        except Exception:
-            return None
-        source = str(data.get("source", "")).strip()
-        if not source:
-            return None
-        candidate = Path(source).expanduser()
-        if (candidate / "src").is_dir() and (candidate / "package.json").is_file():
-            return candidate
+        for version_file in (NEXO_HOME / "version.json", NEXO_HOME / "core" / "version.json"):
+            if not version_file.is_file():
+                continue
+            try:
+                data = json.loads(version_file.read_text())
+            except Exception:
+                continue
+            source = str(data.get("source", "")).strip()
+            if not source:
+                continue
+            candidate = Path(source).expanduser()
+            if (candidate / "src").is_dir() and (candidate / "package.json").is_file():
+                return candidate
         return None
 
     try:

package/src/bootstrap_docs.py

@@ -27,6 +27,14 @@ def _resolve_templates_dir(module_file: str | os.PathLike[str]) -> Path:
     parent = module_dir.parent / "templates"
     if parent.is_dir():
         return parent
+    try:
+        nexo_home_templates = resolve_nexo_home(
+            os.environ.get("NEXO_HOME", str(_user_home() / ".nexo"))
+        ) / "templates"
+    except Exception:
+        nexo_home_templates = Path(os.environ.get("NEXO_HOME", str(_user_home() / ".nexo"))).expanduser() / "templates"
+    if nexo_home_templates.is_dir():
+        return nexo_home_templates
     return direct
 
 

package/src/cli.py

@@ -47,6 +47,7 @@ import time
 from pathlib import Path
 
 from runtime_home import export_resolved_nexo_home
+from runtime_versioning import build_mcp_status, clear_restart_required_marker
 
 NEXO_HOME = export_resolved_nexo_home()
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
@@ -120,6 +121,82 @@ def _fetch_latest_version(timeout_seconds: int = 2) -> str | None:
     return latest
 
 
+def _print_json_or_text(payload: dict, *, as_json: bool = False) -> int:
+    if as_json:
+        print(json.dumps(payload, ensure_ascii=False))
+    else:
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    return 0 if payload.get("ok", True) else 1
+
+
+def _mcp_status(args) -> int:
+    return _print_json_or_text(
+        build_mcp_status(client=getattr(args, "client", "") or ""),
+        as_json=bool(getattr(args, "json", False)),
+    )
+
+
+def _mcp_clear_restart(args) -> int:
+    return _print_json_or_text(
+        clear_restart_required_marker(
+            client=getattr(args, "client", "") or "",
+            installed_version=getattr(args, "installed_version", "") or "",
+            process_version=getattr(args, "process_version", "") or "",
+        ),
+        as_json=bool(getattr(args, "json", False)),
+    )
+
+
+def _continuity_snapshot_write(args) -> int:
+    from continuity import write_snapshot
+
+    result = write_snapshot(
+        conversation_id=args.conversation_id,
+        session_id=args.session_id or "",
+        external_session_id=args.external_session_id or "",
+        client=args.client or "",
+        event_type=args.event_type or "turn_end",
+        payload=args.payload or "",
+        trace_id=args.trace_id or "",
+        idempotency_key=args.idempotency_key or "",
+    )
+    return _print_json_or_text(result, as_json=bool(getattr(args, "json", False)))
+
+
+def _continuity_snapshot_read(args) -> int:
+    from continuity import read_snapshot
+
+    result = read_snapshot(
+        conversation_id=args.conversation_id or "",
+        session_id=args.session_id or "",
+        limit=args.limit or 20,
+    )
+    return _print_json_or_text(result, as_json=bool(getattr(args, "json", False)))
+
+
+def _continuity_resume_bundle(args) -> int:
+    from continuity import build_resume_bundle
+
+    result = build_resume_bundle(
+        conversation_id=args.conversation_id or "",
+        session_id=args.session_id or "",
+        external_session_id=args.external_session_id or "",
+        client=args.client or "",
+        token_budget=args.token_budget or 2000,
+    )
+    return _print_json_or_text(result, as_json=bool(getattr(args, "json", False)))
+
+
+def _continuity_audit(args) -> int:
+    from continuity import continuity_audit
+
+    result = continuity_audit(
+        conversation_id=args.conversation_id,
+        limit=args.limit or 50,
+    )
+    return _print_json_or_text(result, as_json=bool(getattr(args, "json", False)))
+
+
 def _should_refresh_latest_version() -> bool:
     """Decide whether to hit the npm registry to refresh `latest` version.
 
@@ -3075,6 +3152,49 @@ def main():
     dashboard_parser = sub.add_parser("dashboard", help="Web dashboard control")
     dashboard_parser.add_argument("action", choices=["on", "off", "status"], help="Start, stop, or check dashboard")
 
+    mcp_parser = sub.add_parser("mcp", help="MCP runtime status and restart state")
+    mcp_sub = mcp_parser.add_subparsers(dest="mcp_command")
+    mcp_status_p = mcp_sub.add_parser("status", help="Read the current runtime/MCP alignment state")
+    mcp_status_p.add_argument("--client", default="", help="Optional client label such as claude_desktop or codex")
+    mcp_status_p.add_argument("--json", action="store_true", help="JSON output")
+    mcp_clear_p = mcp_sub.add_parser("clear-restart", help="Acknowledge that a client/session reloaded the new runtime")
+    mcp_clear_p.add_argument("--client", default="", help="Client label such as claude_desktop or codex")
+    mcp_clear_p.add_argument("--installed-version", default="")
+    mcp_clear_p.add_argument("--process-version", default="")
+    mcp_clear_p.add_argument("--json", action="store_true", help="JSON output")
+
+    continuity_parser = sub.add_parser("continuity", help="Continuity snapshots and resume bundles")
+    continuity_sub = continuity_parser.add_subparsers(dest="continuity_command")
+    cwrite_p = continuity_sub.add_parser("snapshot-write", help="Write a continuity snapshot")
+    cwrite_p.add_argument("--conversation-id", required=True)
+    cwrite_p.add_argument("--session-id", default="")
+    cwrite_p.add_argument("--external-session-id", default="")
+    cwrite_p.add_argument("--client", default="")
+    cwrite_p.add_argument("--event-type", default="turn_end")
+    cwrite_p.add_argument("--payload", default="")
+    cwrite_p.add_argument("--trace-id", default="")
+    cwrite_p.add_argument("--idempotency-key", default="")
+    cwrite_p.add_argument("--json", action="store_true", help="JSON output")
+
+    cread_p = continuity_sub.add_parser("snapshot-read", help="Read continuity snapshots")
+    cread_p.add_argument("--conversation-id", default="")
+    cread_p.add_argument("--session-id", default="")
+    cread_p.add_argument("--limit", type=int, default=20)
+    cread_p.add_argument("--json", action="store_true", help="JSON output")
+
+    cbundle_p = continuity_sub.add_parser("resume-bundle", help="Build a continuity resume bundle")
+    cbundle_p.add_argument("--conversation-id", default="")
+    cbundle_p.add_argument("--session-id", default="")
+    cbundle_p.add_argument("--external-session-id", default="")
+    cbundle_p.add_argument("--client", default="")
+    cbundle_p.add_argument("--token-budget", type=int, default=2000)
+    cbundle_p.add_argument("--json", action="store_true", help="JSON output")
+
+    caudit_p = continuity_sub.add_parser("audit", help="Read the continuity audit timeline")
+    caudit_p.add_argument("--conversation-id", required=True)
+    caudit_p.add_argument("--limit", type=int, default=50)
+    caudit_p.add_argument("--json", action="store_true", help="JSON output")
+
     # -- desktop bridge (read-only, for NEXO Desktop and any external UI) --
     # v7.4.0 — lifecycle event bridge (guardian-claude-desktop-plan).
     lifecycle_parser = sub.add_parser("lifecycle", help="Conversation lifecycle event handler (v7.4 Desktop bridge)")
@@ -3268,6 +3388,24 @@ def main():
             return _clients_sync(args)
         clients_parser.print_help()
         return 0
+    elif args.command == "mcp":
+        if args.mcp_command == "status":
+            return _mcp_status(args)
+        if args.mcp_command == "clear-restart":
+            return _mcp_clear_restart(args)
+        mcp_parser.print_help()
+        return 0
+    elif args.command == "continuity":
+        if args.continuity_command == "snapshot-write":
+            return _continuity_snapshot_write(args)
+        elif args.continuity_command == "snapshot-read":
+            return _continuity_snapshot_read(args)
+        elif args.continuity_command == "resume-bundle":
+            return _continuity_resume_bundle(args)
+        elif args.continuity_command == "audit":
+            return _continuity_audit(args)
+        continuity_parser.print_help()
+        return 0
     elif args.command == "preferences":
         return _preferences(args)
     elif args.command == "doctor":

package/src/client_sync.py

@@ -143,6 +143,45 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     return DEFAULT_ASSISTANT_NAME
 
 
+def _is_relative_to(path: Path, base: Path) -> bool:
+    try:
+        path.relative_to(base)
+        return True
+    except Exception:
+        return False
+
+
+def _normalize_managed_runtime_root(nexo_home: Path, candidate: Path) -> Path:
+    raw = candidate.expanduser()
+    if raw.name == "server.py":
+        raw = raw.parent
+    try:
+        resolved = raw.resolve()
+    except Exception:
+        resolved = raw.absolute()
+    core_root = (nexo_home / "core").expanduser()
+    current_root = core_root / "current"
+    preferred_targets = []
+    if (core_root / "server.py").is_file():
+        preferred_targets.append(core_root)
+    if (current_root / "server.py").is_file():
+        preferred_targets.append(current_root)
+    if not preferred_targets:
+        return resolved
+    try:
+        core_resolved = core_root.resolve()
+    except Exception:
+        core_resolved = core_root.absolute()
+    version_root = core_resolved / "versions"
+    try:
+        current_resolved = current_root.resolve()
+    except Exception:
+        current_resolved = current_root.absolute()
+    if resolved == current_resolved or _is_relative_to(resolved, version_root):
+        return preferred_targets[0]
+    return resolved
+
+
 def _resolve_runtime_root(nexo_home: Path, runtime_root: str | os.PathLike[str] | None = None) -> Path:
     candidates: list[Path] = []
     if runtime_root:
@@ -155,12 +194,13 @@ def _resolve_runtime_root(nexo_home: Path, runtime_root: str | os.PathLike[str]
 
     seen: set[Path] = set()
     for candidate in candidates:
-        resolved = candidate.resolve()
+        normalized = _normalize_managed_runtime_root(nexo_home, candidate)
+        resolved = normalized.resolve()
         if resolved in seen:
             continue
         seen.add(resolved)
-        if (resolved / "server.py").is_file():
-            return resolved
+        if (normalized / "server.py").is_file():
+            return normalized
     raise FileNotFoundError(f"Could not locate runtime root with server.py (tried {len(seen)} locations)")
 
 
@@ -409,6 +449,7 @@ def build_server_config(
     runtime_root: str | os.PathLike[str] | None = None,
     python_path: str = "",
     operator_name: str = "",
+    client: str = "",
 ) -> dict:
     nexo_home_path = Path(nexo_home).expanduser() if nexo_home else _default_nexo_home()
     runtime_root_path = _resolve_runtime_root(nexo_home_path, runtime_root)
@@ -423,6 +464,9 @@ def build_server_config(
     resolved_name = _resolve_operator_name(nexo_home_path, explicit=operator_name)
     if resolved_name:
         config["env"]["NEXO_NAME"] = resolved_name
+    resolved_client = normalize_client_key(client)
+    if resolved_client:
+        config["env"]["NEXO_MCP_CLIENT"] = resolved_client
     return config
 
 
@@ -436,6 +480,11 @@ def _claude_code_mcp_path(home: Path | None = None) -> Path:
     return base / ".claude.json"
 
 
+def _claude_code_cortex_path(home: Path | None = None) -> Path:
+    base = home or _user_home()
+    return base / ".claude" / "mcp-cortex.json"
+
+
 def _claude_desktop_config_path(home: Path | None = None) -> Path:
     base = home or _user_home()
     if sys.platform == "darwin":
@@ -1022,6 +1071,7 @@ def sync_claude_code(
         runtime_root=runtime_root,
         python_path=python_path,
         operator_name=operator_name,
+        client="claude_code",
     )
     home_path = Path(user_home).expanduser() if user_home else None
     result = _sync_claude_code_settings(
@@ -1039,6 +1089,13 @@ def sync_claude_code(
     )
     result["mcp"] = mcp_result
     result["mcp_path"] = mcp_result.get("path", "")
+    cortex_result = _sync_json_client(
+        _claude_code_cortex_path(home_path),
+        server_config,
+        "claude_code",
+    )
+    result["cortex_mcp"] = cortex_result
+    result["cortex_mcp_path"] = cortex_result.get("path", "")
     bootstrap_result = sync_client_bootstrap(
         "claude_code",
         nexo_home=nexo_home,
@@ -1066,6 +1123,7 @@ def sync_claude_desktop(
         runtime_root=runtime_root,
         python_path=python_path,
         operator_name=operator_name,
+        client="claude_desktop",
     )
     resolved_name = server_config.get("env", {}).get("NEXO_NAME", "") or _resolve_operator_name(
         Path(nexo_home).expanduser() if nexo_home else _default_nexo_home(),
@@ -1097,6 +1155,7 @@ def sync_codex(
         runtime_root=runtime_root,
         python_path=python_path,
         operator_name=operator_name,
+        client="codex",
     )
     codex_bin = shutil.which("codex")
     config_path = _codex_config_path(home_path)