nexo-brain 7.18.0 → 7.19.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.18.0",
+  "version": "7.19.0",
   "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.18.0` is the current packaged-runtime line. Minor release over v7.17.8 - Brain adds the Local Context Layer: a local-only background memory index with checkpoints, extraction, graph links, embeddings, MCP/CLI controls, and pre-action evidence for NEXO agents.
+Version `7.19.0` is the current packaged-runtime line. Minor release over v7.18.1 — bundle-managed installations (NEXO Desktop `brain-bundle/`) can now pin Brain to the host application release cycle via `NEXO_BRAIN_AUTO_UPDATE=false`, and the server auto-exits with code 75 on fingerprint mismatch so MCP clients respawn the server with the new code instead of leaving stale `server.py` processes alive.
+
+Previously in `7.18.1`: patch release over v7.18.0 - packaged Brain runtimes now include the `local_context` package, so Desktop Local Memory and `nexo local-context` do not get stuck behind `ModuleNotFoundError` or zero-file status; the local-index service also keeps detecting newly mounted volumes automatically.
+
+Previously in `7.18.0`: minor release over v7.17.8 - Brain adds the Local Context Layer: a local-only background memory index with checkpoints, extraction, graph links, embeddings, MCP/CLI controls, and pre-action evidence for NEXO agents.
 
 Previously in `7.17.8`: patch release over v7.17.7 - standalone `nexo chat` now surfaces macOS Full Disk Access guidance, and Brain clears stale permission state after a live access probe succeeds.
 

package/bin/nexo-brain.js

@@ -1123,7 +1123,7 @@ function getCoreRuntimeFlatFiles(srcDir = path.join(__dirname, "..", "src")) {
 }
 
 function getCoreRuntimePackages() {
-  return ["db", "cognitive", "doctor"];
+  return ["db", "cognitive", "doctor", "local_context"];
 }
 
 // Brain contracts — files the NEXO Brain publishes to consumers like

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.18.0",
+  "version": "7.19.0",
   "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

@@ -4350,7 +4350,7 @@ def _restore_runtime_tree(backup_dir: str, dest: Path = NEXO_HOME) -> None:
 def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_HOME, progress_fn=None) -> dict:
     import shutil
 
-    packages = ["db", "cognitive", "doctor", "dashboard", "rules", "crons", "hooks", "presets"]
+    packages = ["db", "cognitive", "doctor", "local_context", "dashboard", "rules", "crons", "hooks", "presets"]
     flat_files = _runtime_flat_files(src_dir)
     copied_packages = 0
     copied_files = 0
@@ -5372,6 +5372,11 @@ def startup_preflight(*, entrypoint: str, interactive: bool = False) -> dict:
             return result
 
         try:
+            env_auto_update = os.environ.get("NEXO_BRAIN_AUTO_UPDATE", "").strip().lower()
+            if env_auto_update in ("0", "false", "off", "no"):
+                result["skipped_reason"] = "auto_update disabled via NEXO_BRAIN_AUTO_UPDATE env var"
+                _write_update_summary(result)
+                return result
             last_check = _read_last_check()
             now = time.time()
             schedule_file = _runtime_config_dir(NEXO_HOME) / "schedule.json"

package/src/local_context/api.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import stat
 import hashlib
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -15,9 +16,14 @@ from db._schema import run_migrations
 from . import embeddings
 from .extractors import chunk_text, entities, extract_text, summarize
 from .logging import log_event, tail
-from .privacy import classify_path, should_extract
+from .privacy import classify_path, should_extract, should_skip_tree
 from .util import content_hash, json_dumps, json_loads, norm_path, now, quick_fingerprint, redact_path, stable_id, system_label, tokenize
 
+LOCAL_INDEX_SERVICE_LABEL = "com.nexo.local-index"
+LOCAL_INDEX_SCRIPT_NAME = "nexo-local-index.py"
+LOCAL_INDEX_WINDOWS_TASK = "NEXO Local Memory"
+LOCAL_INDEX_LINUX_UNIT = "nexo-local-index.service"
+
 
 def ensure_ready() -> None:
     init_db()
@@ -66,20 +72,62 @@ def list_roots() -> list[dict]:
     return [dict(row) for row in rows]
 
 
+def _dedupe_roots(roots: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for root in roots:
+        normalized = norm_path(root)
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        result.append(normalized)
+    return result
+
+
+def _mounted_volume_roots() -> list[str]:
+    candidates: list[Path] = []
+    if sys.platform == "darwin":
+        candidates.extend((Path("/Volumes")).iterdir() if Path("/Volumes").is_dir() else [])
+    elif sys.platform.startswith("win"):
+        candidates.extend(Path(f"{letter}:\\") for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+    else:
+        user = os.environ.get("USER") or os.environ.get("USERNAME") or ""
+        mount_bases = [Path("/mnt")]
+        if user:
+            mount_bases.extend([Path("/media") / user, Path("/run/media") / user])
+        for base in mount_bases:
+            if base.is_dir():
+                candidates.extend(base.iterdir())
+
+    roots: list[str] = []
+    root_resolved = Path("/").resolve()
+    for candidate in candidates:
+        try:
+            if candidate.name.startswith(".") or not candidate.is_dir():
+                continue
+            resolved = candidate.resolve()
+            if resolved == root_resolved:
+                continue
+            roots.append(str(candidate))
+        except Exception:
+            continue
+    return roots
+
+
 def default_roots() -> list[str]:
     home = Path.home()
     configured = os.environ.get("NEXO_LOCAL_INDEX_DEFAULT_ROOTS", "").strip()
     if configured:
-        return [norm_path(item) for item in configured.split(os.pathsep) if item.strip()]
-    return [norm_path(home)]
+        return _dedupe_roots([item for item in configured.split(os.pathsep) if item.strip()])
+    return _dedupe_roots([str(home), *_mounted_volume_roots()])
 
 
 def ensure_default_roots() -> dict:
-    existing = list_roots()
-    if existing:
-        return {"ok": True, "created": 0, "roots": existing}
+    existing_paths = {row["root_path"] for row in list_roots()}
     created = []
     for root in default_roots():
+        if root in existing_paths:
+            continue
         candidate = Path(root).expanduser()
         if candidate.exists() and candidate.is_dir():
             created.append(add_root(str(candidate), mode="normal", depth=2))
@@ -295,6 +343,8 @@ def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None,
         current = stack.pop()
         if _is_excluded(str(current), exclusions):
             continue
+        if current != root and should_skip_tree(str(current)):
+            continue
         try:
             st = current.stat()
         except Exception:
@@ -314,6 +364,8 @@ def _iter_files(root: Path, exclusions: list[str], *, limit: int | None = None,
             if entry.is_symlink():
                 continue
             if entry.is_dir():
+                if should_skip_tree(str(entry)):
+                    continue
                 dirs.append(entry)
                 continue
             if entry.is_file():
@@ -611,6 +663,136 @@ def _problem_rows(conn) -> list[dict]:
     ]
 
 
+def _command_output(args: list[str], *, timeout: int = 2) -> tuple[int, str, str]:
+    try:
+        result = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
+    except FileNotFoundError as exc:
+        return 127, "", str(exc)
+    except subprocess.TimeoutExpired as exc:
+        return 124, exc.stdout or "", exc.stderr or "timeout"
+    except Exception as exc:
+        return 1, "", str(exc)
+    return result.returncode, result.stdout or "", result.stderr or ""
+
+
+def _process_running(pattern: str) -> bool:
+    if system_label() == "windows":
+        command = (
+            "$pattern = '" + pattern.replace("'", "''") + "'; "
+            "$match = Get-CimInstance Win32_Process | "
+            "Where-Object { $_.CommandLine -like \"*$pattern*\" } | "
+            "Select-Object -First 1 -ExpandProperty ProcessId; "
+            "if ($match) { Write-Output $match }"
+        )
+        code, stdout, _ = _command_output(["powershell", "-NoProfile", "-Command", command], timeout=4)
+        return code == 0 and bool(stdout.strip())
+
+    code, stdout, _ = _command_output(["pgrep", "-f", pattern], timeout=2)
+    if code == 0 and stdout.strip():
+        return True
+    code, stdout, _ = _command_output(["ps", "aux"], timeout=2)
+    return code == 0 and pattern in stdout
+
+
+def _macos_local_index_service_status() -> dict:
+    plist_path = Path.home() / "Library" / "LaunchAgents" / f"{LOCAL_INDEX_SERVICE_LABEL}.plist"
+    installed = plist_path.is_file()
+    running = False
+    active_process = False
+    pid = ""
+
+    code, stdout, _ = _command_output(["launchctl", "list"], timeout=2)
+    if code == 0:
+        for line in stdout.splitlines():
+            parts = line.split()
+            if len(parts) >= 3 and parts[-1] == LOCAL_INDEX_SERVICE_LABEL:
+                installed = True
+                pid = parts[0]
+                running = True
+                active_process = pid.isdigit() and int(pid) > 0
+                break
+
+    if not installed:
+        code, _, _ = _command_output(["launchctl", "print", f"gui/{os.getuid()}/{LOCAL_INDEX_SERVICE_LABEL}"], timeout=2)
+        installed = code == 0
+
+    if not active_process:
+        active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = running or active_process
+
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "launchagent",
+        "label": LOCAL_INDEX_SERVICE_LABEL,
+        "pid": pid,
+        "config_path": str(plist_path),
+    }
+
+
+def _windows_local_index_service_status() -> dict:
+    command = (
+        "$task = Get-ScheduledTask -TaskName 'NEXO Local Memory' -ErrorAction SilentlyContinue; "
+        "if ($task) { Write-Output $task.State }"
+    )
+    code, stdout, _ = _command_output(["powershell", "-NoProfile", "-Command", command], timeout=4)
+    task_state = stdout.strip()
+    task_state_key = task_state.lower()
+    installed = code == 0 and bool(task_state)
+    active_process = task_state_key == "running"
+    if not active_process:
+        active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = task_state_key in {"ready", "running"} or active_process
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "scheduled_task",
+        "task_name": LOCAL_INDEX_WINDOWS_TASK,
+        "task_state": task_state,
+    }
+
+
+def _linux_local_index_service_status() -> dict:
+    unit_dir = Path.home() / ".config" / "systemd" / "user"
+    unit_path = unit_dir / LOCAL_INDEX_LINUX_UNIT
+    timer_path = unit_dir / "nexo-local-index.timer"
+    installed = unit_path.is_file() or timer_path.is_file()
+
+    code, stdout, _ = _command_output(["systemctl", "--user", "is-active", LOCAL_INDEX_LINUX_UNIT], timeout=2)
+    unit_state = stdout.strip()
+    running = code == 0 and unit_state == "active"
+    active_process = _process_running(LOCAL_INDEX_SCRIPT_NAME)
+    running = running or active_process
+
+    return {
+        "installed": installed,
+        "running": running,
+        "active_process": active_process,
+        "manager": "systemd_user",
+        "unit": LOCAL_INDEX_LINUX_UNIT,
+        "unit_state": unit_state,
+        "config_path": str(unit_path),
+    }
+
+
+def _local_index_service_status() -> dict:
+    platform_value = system_label()
+    if platform_value == "macos":
+        service = _macos_local_index_service_status()
+    elif platform_value == "windows":
+        service = _windows_local_index_service_status()
+    else:
+        service = _linux_local_index_service_status()
+    service.setdefault("installed", False)
+    service.setdefault("running", False)
+    service["platform"] = platform_value
+    service["started_at"] = ""
+    service["last_heartbeat_at"] = ""
+    return service
+
+
 def status() -> dict:
     conn = _conn()
     paused = _is_paused()
@@ -628,16 +810,11 @@ def status() -> dict:
     ).fetchall()
     for row in by_volume:
         volumes.append({"id": row["volume_id"], "label": row["volume_id"] or "Disk", "files": row["files"], "status": "active"})
+    service = _local_index_service_status()
+    service["state"] = "paused" if paused else ("idle" if pending == 0 else "indexing")
     return {
         "ok": True,
-        "service": {
-            "installed": False,
-            "running": False,
-            "state": "paused" if paused else ("idle" if pending == 0 else "indexing"),
-            "platform": system_label(),
-            "started_at": "",
-            "last_heartbeat_at": "",
-        },
+        "service": service,
         "global": {
             "phase": "paused" if paused else ("idle" if pending == 0 else "light_extraction"),
             "percent": percent,

package/src/local_context/privacy.py

@@ -36,10 +36,24 @@ NOISY_PARTS = {
     "dist",
     "build",
     ".git",
+    ".venv",
+    "venv",
+    "env",
     ".cache",
     "cache",
     "coverage",
     "__pycache__",
+    ".tox",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".parcel-cache",
+    ".bun",
+    ".gradle",
+    "target",
 }
 
 SYSTEM_PARTS = {
@@ -71,6 +85,15 @@ def classify_path(path: str) -> tuple[int, str, str]:
     return 2, "normal", "default"
 
 
+def should_skip_tree(path: str) -> bool:
+    p = Path(path)
+    lowered = str(p).replace("\\", "/").lower()
+    parts = {part.lower() for part in p.parts}
+    if any(item in lowered for item in SYSTEM_PARTS):
+        return True
+    return bool(parts & NOISY_PARTS)
+
+
 def should_extract(path: str, depth: int) -> bool:
     if depth < 2:
         return False

package/src/runtime_versioning.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import hashlib
 import json
 import os
 import re
 import shutil
+import sys
 import time
 from dataclasses import dataclass
 from pathlib import Path
@@ -814,6 +816,31 @@ def prime_process_fingerprint() -> str:
     return PROCESS_FINGERPRINT
 
 
+_DRIFT_AUTOEXIT_SCHEDULED = False
+_DRIFT_EXIT_CODE = 75
+_DRIFT_EXIT_DELAY_SECONDS = 0.5
+
+
+def _request_drift_exit() -> None:
+    try:
+        os._exit(_DRIFT_EXIT_CODE)
+    except Exception:
+        os._exit(1)
+
+
+def _schedule_drift_autoexit() -> None:
+    global _DRIFT_AUTOEXIT_SCHEDULED
+    if _DRIFT_AUTOEXIT_SCHEDULED:
+        return
+    _DRIFT_AUTOEXIT_SCHEDULED = True
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        _request_drift_exit()
+        return
+    loop.call_later(_DRIFT_EXIT_DELAY_SECONDS, _request_drift_exit)
+
+
 @dataclass
 class RestartRequiredMiddleware(Middleware):
     client: str = ""
@@ -893,4 +920,7 @@ class RestartRequiredMiddleware(Middleware):
             "reason": state["reason"],
             "client_action": state["client_action"],
         }
-        return await self._tool_result_for_restart_required(context, payload)
+        result = await self._tool_result_for_restart_required(context, payload)
+        if state.get("reason") == "fingerprint_mismatch":
+            _schedule_drift_autoexit()
+        return result