nexo-brain 7.20.18 → 7.20.20

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.14",
+  "version": "7.20.19",
   "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.20.18` is the current packaged-runtime line. Patch release over v7.20.17 — Desktop-managed setup now preserves a completed onboarding flag when Brain is later invoked with the non-interactive `--skip` bootstrap path.
+Version `7.20.19` is the current packaged-runtime line. Patch release over v7.20.18 — Local Memory status and long first-indexing runs stay stable during Desktop-managed updates; stale macOS Full Disk Access denials are cleared after a live access probe succeeds.
+
+Previously in `7.20.18`: patch release over v7.20.17 — Desktop-managed setup now preserves a completed onboarding flag when Brain is later invoked with the non-interactive `--skip` bootstrap path.
 
 Previously in `7.20.17`: patch release over v7.20.16 — validated DB backups now tolerate tiny live-write growth from the Local Memory indexer while still rejecting real protected-table loss.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.20.18",
+  "version": "7.20.20",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/cli.py

@@ -140,6 +140,166 @@ def _mcp_status(args) -> int:
     )
 
 
+def _mcp_write_message(stdin, payload: dict) -> None:
+    raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    stdin.write(raw + b"\n")
+    stdin.flush()
+
+
+def _mcp_reader(stdout, queue) -> None:
+    while True:
+        try:
+            line = stdout.readline()
+            if not line:
+                return
+            text = line.decode("utf-8", errors="replace").strip()
+            if not text:
+                continue
+            queue.put(json.loads(text))
+        except Exception as exc:
+            queue.put({"_reader_error": str(exc)})
+            return
+
+
+def _stderr_reader(stderr, lines: list[str]) -> None:
+    while True:
+        chunk = stderr.readline()
+        if not chunk:
+            return
+        try:
+            lines.append(chunk.decode("utf-8", errors="replace").rstrip())
+        except Exception:
+            lines.append(repr(chunk))
+        del lines[:-80]
+
+
+def _mcp_wait_for_response(queue, request_id: int, timeout_seconds: float) -> dict:
+    import queue as queue_module
+
+    deadline = time.monotonic() + max(timeout_seconds, 0.1)
+    while time.monotonic() < deadline:
+        remaining = max(deadline - time.monotonic(), 0.05)
+        try:
+            message = queue.get(timeout=remaining)
+        except queue_module.Empty:
+            break
+        if message.get("_reader_error"):
+            raise RuntimeError(message["_reader_error"])
+        if message.get("id") == request_id:
+            return message
+    raise TimeoutError(f"MCP response {request_id} timed out")
+
+
+def _mcp_probe(args) -> int:
+    import queue as queue_module
+    import threading
+
+    timeout_ms = int(getattr(args, "timeout_ms", 8000) or 8000)
+    timeout_seconds = max(timeout_ms / 1000.0, 1.0)
+    started_at = time.monotonic()
+    server_path = NEXO_CODE / "server.py"
+    env = os.environ.copy()
+    env["NEXO_MCP_PROBE"] = "1"
+    env.setdefault("NEXO_MCP_PLUGIN_MODE", getattr(args, "plugin_mode", None) or "none")
+    env.setdefault("NEXO_MCP_RUN_STARTUP_PREFLIGHT", "0")
+    client = str(getattr(args, "client", "") or "").strip()
+    if client:
+        env["NEXO_MCP_CLIENT"] = client
+
+    proc = None
+    stderr_lines: list[str] = []
+    try:
+        proc = subprocess.Popen(
+            [sys.executable, str(server_path)],
+            cwd=str(NEXO_CODE),
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+        )
+        responses = queue_module.Queue()
+        threading.Thread(target=_mcp_reader, args=(proc.stdout, responses), daemon=True).start()
+        threading.Thread(target=_stderr_reader, args=(proc.stderr, stderr_lines), daemon=True).start()
+
+        _mcp_write_message(proc.stdin, {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "nexo-mcp-probe", "version": _get_version()},
+            },
+        })
+        init_response = _mcp_wait_for_response(responses, 1, timeout_seconds)
+        if init_response.get("error"):
+            raise RuntimeError(f"MCP initialize failed: {init_response['error']}")
+
+        _mcp_write_message(proc.stdin, {
+            "jsonrpc": "2.0",
+            "method": "notifications/initialized",
+            "params": {},
+        })
+        _mcp_write_message(proc.stdin, {
+            "jsonrpc": "2.0",
+            "id": 2,
+            "method": "tools/list",
+            "params": {},
+        })
+        tools_response = _mcp_wait_for_response(responses, 2, timeout_seconds)
+        if tools_response.get("error"):
+            raise RuntimeError(f"MCP tools/list failed: {tools_response['error']}")
+        tools = ((tools_response.get("result") or {}).get("tools") or [])
+        tool_names = [
+            str(tool.get("name") or "")
+            for tool in tools
+            if isinstance(tool, dict) and tool.get("name")
+        ]
+        required = ["nexo_startup", "nexo_heartbeat", "nexo_task_open", "nexo_guard_check"]
+        missing = [name for name in required if name not in tool_names]
+        ok = not missing and len(tool_names) > 0
+        payload = {
+            "ok": ok,
+            "mcp_ready": ok,
+            "probe_ok": ok,
+            "tools_available": len(tool_names) > 0,
+            "tool_count": len(tool_names),
+            "required_tools_present": not missing,
+            "missing_required_tools": missing,
+            "client": client,
+            "plugin_mode": env.get("NEXO_MCP_PLUGIN_MODE"),
+            "elapsed_ms": int((time.monotonic() - started_at) * 1000),
+            "stderr_tail": "\n".join(stderr_lines[-12:]),
+        }
+        return _print_json_or_text(payload, as_json=bool(getattr(args, "json", False)))
+    except Exception as exc:
+        payload = {
+            "ok": False,
+            "mcp_ready": False,
+            "probe_ok": False,
+            "error": "mcp_probe_failed",
+            "message": str(exc),
+            "client": client,
+            "elapsed_ms": int((time.monotonic() - started_at) * 1000),
+            "stderr_tail": "\n".join(stderr_lines[-20:]),
+        }
+        return _print_json_or_text(payload, as_json=bool(getattr(args, "json", False)))
+    finally:
+        if proc is not None:
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+            try:
+                proc.wait(timeout=2)
+            except Exception:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+
+
 def _mcp_clear_restart(args) -> int:
     return _print_json_or_text(
         clear_restart_required_marker(
@@ -1389,6 +1549,17 @@ def _local_context_models(args) -> int:
     return _local_context_emit(local_context.model_status(), args)
 
 
+def _local_context_performance(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_performance_command", "") or "status")
+    if command == "set":
+        return _local_context_emit(
+            local_context.set_performance_profile(getattr(args, "profile", "") or "medium"),
+            args,
+        )
+    return _local_context_emit({"ok": True, "performance": local_context.performance_config()}, args)
+
+
 def _local_context_service_config(args) -> int:
     from local_context import api as local_context_api
     return _local_context_emit(
@@ -3238,6 +3409,14 @@ def main():
     local_context_models_warmup_p.add_argument("--allow-download", action="store_true", help="Allow model downloads")
     local_context_models_warmup_p.add_argument("--json", action="store_true", help="JSON output")
 
+    local_context_performance_p = local_context_sub.add_parser("performance", help="Show or change local memory indexing speed")
+    local_context_performance_sub = local_context_performance_p.add_subparsers(dest="local_context_performance_command")
+    local_context_performance_status_p = local_context_performance_sub.add_parser("status", help="Show active indexing speed")
+    local_context_performance_status_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_performance_set_p = local_context_performance_sub.add_parser("set", help="Set indexing speed")
+    local_context_performance_set_p.add_argument("profile", choices=["low", "medium", "high", "extreme"], help="Indexing speed profile")
+    local_context_performance_set_p.add_argument("--json", action="store_true", help="JSON output")
+
     local_context_asset_p = local_context_sub.add_parser("asset", help="Inspect or purge one indexed asset")
     local_context_asset_sub = local_context_asset_p.add_subparsers(dest="local_context_asset_command")
     local_context_asset_get_p = local_context_asset_sub.add_parser("get", help="Get indexed asset details")
@@ -3543,6 +3722,11 @@ def main():
     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_probe_p = mcp_sub.add_parser("probe", help="Launch the MCP server and verify initialize + tools/list")
+    mcp_probe_p.add_argument("--client", default="", help="Optional client label such as claude_desktop or codex")
+    mcp_probe_p.add_argument("--timeout-ms", type=int, default=8000)
+    mcp_probe_p.add_argument("--plugin-mode", default="none", choices=["essential", "none", "full"])
+    mcp_probe_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="")
@@ -3784,6 +3968,10 @@ def main():
             if not args.local_context_models_command:
                 args.local_context_models_command = "status"
             return _local_context_models(args)
+        if args.local_context_command == "performance":
+            if not args.local_context_performance_command:
+                args.local_context_performance_command = "status"
+            return _local_context_performance(args)
         if args.local_context_command == "asset":
             if not args.local_context_asset_command:
                 local_context_asset_p.print_help()
@@ -3842,6 +4030,8 @@ def main():
     elif args.command == "mcp":
         if args.mcp_command == "status":
             return _mcp_status(args)
+        if args.mcp_command == "probe":
+            return _mcp_probe(args)
         if args.mcp_command == "clear-restart":
             return _mcp_clear_restart(args)
         mcp_parser.print_help()

package/src/crons/manifest.json

@@ -311,7 +311,7 @@
       "recovery_policy": "restart",
       "idempotent": true,
       "max_catchup_age": 600,
-      "stuck_after_seconds": 900,
+      "stuck_after_seconds": 21600,
       "run_on_boot": true,
       "run_on_wake": true
     },

package/src/runtime_power.py

@@ -566,6 +566,14 @@ def detect_full_disk_access_reasons(*, system: str | None = None) -> list[str]:
     if system != "Darwin":
         return []
 
+    try:
+        probe = probe_full_disk_access()
+        if probe.get("granted") is True:
+            clear_full_disk_access_required_state()
+            return []
+    except Exception:
+        pass
+
     reasons: list[str] = []
     if _is_protected_macos_path(NEXO_HOME):
         reasons.append(

package/src/scripts/nexo-backup.sh

@@ -14,13 +14,26 @@ mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
 
 # Hourly backup
 TIMESTAMP=$(date +%Y-%m-%d-%H%M)
-sqlite3 "$DB" ".backup '$BACKUP_DIR/nexo-$TIMESTAMP.db'"
+BACKUP_FILE="$BACKUP_DIR/nexo-$TIMESTAMP.db"
+TMP_BACKUP="$BACKUP_FILE.tmp.$$"
+rm -f "$TMP_BACKUP"
+if sqlite3 -cmd ".timeout 60000" "$DB" <<SQL
+PRAGMA busy_timeout=60000;
+.backup '$TMP_BACKUP'
+SQL
+then
+    mv "$TMP_BACKUP" "$BACKUP_FILE"
+else
+    rm -f "$TMP_BACKUP"
+    echo "NEXO backup failed: database busy or unavailable" >&2
+    exit 1
+fi
 
 # Weekly backup — save one per week (Sundays)
 WEEK=$(date +%Y-W%V)
 WEEKLY_FILE="$WEEKLY_DIR/weekly-$WEEK.db"
-if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ]; then
-    cp "$BACKUP_DIR/nexo-$TIMESTAMP.db" "$WEEKLY_FILE"
+if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ] && [ -f "$BACKUP_FILE" ]; then
+    cp "$BACKUP_FILE" "$WEEKLY_FILE"
 fi
 
 # Cleanup: hourly >48h, weekly >90 days

package/src/scripts/nexo-local-index.py

@@ -3,7 +3,7 @@
 # nexo: description=Cooperative local memory indexing cycle for Brain/Desktop.
 # nexo: category=memory
 # nexo: runtime=python
-# nexo: timeout=900
+# nexo: timeout=21600
 # nexo: cron_id=local-index
 # nexo: interval_seconds=60
 # nexo: schedule_required=true
@@ -12,6 +12,7 @@
 # nexo: run_on_wake=true
 # nexo: idempotent=true
 # nexo: max_catchup_age=600
+# nexo: stuck_after_seconds=21600
 # nexo: doctor_allow_db=true
 
 from __future__ import annotations

package/src/server.py

@@ -259,8 +259,56 @@ def _run_startup_preflight_sync() -> None:
         print(f"[NEXO auto-update] error: {e}", file=sys.stderr)
 
 
+_ESSENTIAL_MCP_STARTUP_PLUGINS = (
+    "cards.py",
+    "doctor.py",
+    "episodic_memory.py",
+    "evolution.py",
+    "lifecycle_events.py",
+    "outcomes.py",
+    "preferences.py",
+    "protocol.py",
+    "recover.py",
+    "skills.py",
+    "user_state_tools.py",
+    "workflow.py",
+)
+
+
+def _env_flag(name: str, *, default: bool = False) -> bool:
+    value = os.environ.get(name)
+    if value is None:
+        return default
+    return str(value).strip().lower() in {"1", "true", "yes", "on", "y", "si"}
+
+
+def _mcp_startup_plugin_mode() -> str:
+    return str(os.environ.get("NEXO_MCP_PLUGIN_MODE", "none") or "none").strip().lower()
+
+
+def _load_startup_plugins() -> None:
+    mode = _mcp_startup_plugin_mode()
+    if mode in {"none", "off", "0", "false"}:
+        print("[NEXO] MCP dynamic plugin loading skipped.", file=sys.stderr)
+        return
+    if mode in {"full", "all", "legacy"}:
+        load_all_plugins(mcp)
+        return
+
+    if mode not in {"essential", "fast", "default"}:
+        print(f"[NEXO] Unknown NEXO_MCP_PLUGIN_MODE={mode!r}; using essential plugins.", file=sys.stderr)
+
+    loaded = 0
+    for filename in _ESSENTIAL_MCP_STARTUP_PLUGINS:
+        try:
+            loaded += int(load_plugin(mcp, filename) or 0)
+        except Exception as exc:
+            print(f"[PLUGIN ERROR] {filename}: {exc}", file=sys.stderr)
+    print(f"[NEXO] MCP essential plugins ready: {loaded} tools.", file=sys.stderr)
+
+
 def _server_init():
-    """Run all side effects: signals, PID, DB, auto-update, plugins.
+    """Run side effects needed by the MCP server.
 
     Called only when the server is actually started (not on import).
     """
@@ -268,20 +316,26 @@ def _server_init():
     signal.signal(signal.SIGINT, _shutdown_handler)
 
     # ── Write PID file for stale process detection ─────────────────
-    data_dir = _data_dir()
-    os.makedirs(data_dir, exist_ok=True)
-    _pid_file = os.path.join(data_dir, "nexo.pid")
-    with open(_pid_file, "w") as f:
-        f.write(str(os.getpid()))
+    if not _env_flag("NEXO_MCP_PROBE"):
+        data_dir = _data_dir()
+        os.makedirs(data_dir, exist_ok=True)
+        _pid_file = os.path.join(data_dir, "nexo.pid")
+        with open(_pid_file, "w") as f:
+            f.write(str(os.getpid()))
 
     # ── Database initialization with recovery ─────────────────────
     _init_db_or_exit()
 
-    # ── Auto-update / startup preflight (synchronous) ─────────────
-    _run_startup_preflight_sync()
+    # ── Auto-update / startup preflight ───────────────────────────
+    # The MCP client waits for an immediate JSON-RPC handshake. Running update
+    # checks here can block the transport and make clients start without NEXO.
+    if _env_flag("NEXO_MCP_RUN_STARTUP_PREFLIGHT"):
+        _run_startup_preflight_sync()
+    else:
+        print("[NEXO] MCP startup preflight deferred.", file=sys.stderr)
 
     # ── Load plugins ───────────────────────────────────────────────
-    load_all_plugins(mcp)
+    _load_startup_plugins()
 
 
 mcp = FastMCP(