nexo-brain 7.25.2 → 7.25.4

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.25.1",
+  "version": "7.25.4",
   "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.25.1` is the current packaged-runtime line. Patch release over v7.25.0 - shell guardrails skip non-path curl/wget arguments and daily protocol-debt audits keep ERROR classes visible by severity and type.
+Version `7.25.4` is the current packaged-runtime line. Patch release over v7.25.3 - Local Memory starts from safe user-content and email roots, adds configurable included/excluded file types, and cleans legacy whole-disk index state with backup or archive-rebuild safety.
+
+Previously in `7.25.3`: patch release over v7.25.2 - Desktop-managed Brain installs require the same Python ABI as the bundled wheels and repair incompatible managed virtual environments before reuse.
 
 Previously in `7.25.0`: minor release over v7.24.0 - Memory Fabric links transcript lookup, historical backup diary recovery, unified search and knowledge graph evidence so memories are not available only inside expiring snapshots.
 

package/bin/nexo-brain.js

@@ -57,6 +57,8 @@ const DEFAULT_ASSISTANT_NAME = "Nova";
 const RESERVED_ASSISTANT_NAME_KEYS = new Set(["nexo", "nexobrain", "nexodesktop"]);
 const MIN_INSTALLER_PYTHON_MAJOR = 3;
 const MIN_INSTALLER_PYTHON_MINOR = 10;
+const DESKTOP_BUNDLED_WHEEL_PYTHON_MAJOR = 3;
+const DESKTOP_BUNDLED_WHEEL_PYTHON_MINOR = 12;
 
 function normalizeAssistantNameCandidate(value) {
   return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
@@ -278,11 +280,25 @@ function pythonVersionMeetsMinimum(versionText) {
     || (major === MIN_INSTALLER_PYTHON_MAJOR && minor >= MIN_INSTALLER_PYTHON_MINOR);
 }
 
+function pythonVersionMatchesDesktopBundle(versionText) {
+  const match = String(versionText || "").trim().match(/^(\d+)\.(\d+)(?:\.|$)/);
+  if (!match) return false;
+  return Number(match[1]) === DESKTOP_BUNDLED_WHEEL_PYTHON_MAJOR
+    && Number(match[2]) === DESKTOP_BUNDLED_WHEEL_PYTHON_MINOR;
+}
+
+function pythonVersionUsableForInstaller(versionText) {
+  if (!pythonVersionMeetsMinimum(versionText)) return false;
+  if (isDesktopManagedInstall()) return pythonVersionMatchesDesktopBundle(versionText);
+  return true;
+}
+
 function resolveInstallerPython() {
   const candidates = [
     process.env.NEXO_BOOTSTRAP_PYTHON,
     process.env.NEXO_RUNTIME_PYTHON,
     process.env.NEXO_PYTHON,
+    run("which python3.12"),
     run("which python3"),
     run("which python"),
   ].filter(Boolean);
@@ -292,7 +308,7 @@ function resolveInstallerPython() {
     if (!clean || seen.has(clean)) continue;
     seen.add(clean);
     const version = pythonVersion(clean);
-    if (version && pythonVersionMeetsMinimum(version)) return clean;
+    if (version && pythonVersionUsableForInstaller(version)) return clean;
   }
   return "";
 }
@@ -366,9 +382,11 @@ function uniqueBackupPath(targetPath, suffix) {
 function ensureManagedVenvCompatible(venvPath, venvPython) {
   if (!fs.existsSync(venvPython)) return;
   const version = pythonVersion(venvPython);
-  if (version && pythonVersionMeetsMinimum(version)) return;
+  if (version && pythonVersionUsableForInstaller(version)) return;
 
-  const reason = version ? `Python ${version}` : "an unreadable Python executable";
+  const reason = version
+    ? `Python ${version}${isDesktopManagedInstall() ? " (Desktop bundle requires Python 3.12)" : ""}`
+    : "an unreadable Python executable";
   const backupPath = uniqueBackupPath(venvPath, "unsupported-python");
   log(`  Existing Python virtual environment uses ${reason}; moving it aside to recreate.`);
   try {
@@ -3300,14 +3318,14 @@ async function runSetup() {
     }
     if (!python) {
       log("Python 3 not found and couldn't install automatically.");
-      log(platform === "darwin" ? "Install it: brew install python3" : "Install it: sudo apt install python3");
+      log(platform === "darwin" ? "Install it: brew install python@3.12" : "Install it: sudo apt install python3");
       process.exit(1);
     }
   }
   const pyVersion = pythonVersion(python);
-  if (!pyVersion || !pythonVersionMeetsMinimum(pyVersion)) {
+  if (!pyVersion || !pythonVersionUsableForInstaller(pyVersion)) {
     log(pyVersion
-      ? `Python at ${python} is ${pyVersion}; NEXO Brain requires Python >=${MIN_INSTALLER_PYTHON_MAJOR}.${MIN_INSTALLER_PYTHON_MINOR}.`
+      ? `Python at ${python} is ${pyVersion}; NEXO Brain requires ${isDesktopManagedInstall() ? "Python 3.12 for Desktop bundled wheels" : `Python >=${MIN_INSTALLER_PYTHON_MAJOR}.${MIN_INSTALLER_PYTHON_MINOR}`}.`
       : `Python at ${python || "(not found)"} is not executable.`);
     process.exit(1);
   }
@@ -3618,7 +3636,7 @@ async function runSetup() {
   }
   if (fs.existsSync(venvPython)) {
     const venvVersion = pythonVersion(venvPython);
-    if (!venvVersion || !pythonVersionMeetsMinimum(venvVersion)) {
+    if (!venvVersion || !pythonVersionUsableForInstaller(venvVersion)) {
       log(`Python virtual environment is unsupported after creation (${venvVersion || "unknown version"}).`);
       process.exit(1);
     }

package/package.json

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

@@ -21,7 +21,7 @@ import time
 from pathlib import Path
 
 try:
-    from product_mode import enforce_desktop_product_contract
+    from product_mode import desktop_product_requested, enforce_desktop_product_contract
 except ModuleNotFoundError as exc:
     if getattr(exc, "name", "") != "product_mode":
         raise
@@ -30,7 +30,7 @@ except ModuleNotFoundError as exc:
         core_path = str(_core_runtime)
         if core_path not in sys.path:
             sys.path.insert(0, core_path)
-    from product_mode import enforce_desktop_product_contract
+    from product_mode import desktop_product_requested, enforce_desktop_product_contract
 from runtime_home import export_resolved_nexo_home, managed_nexo_home
 
 try:
@@ -939,14 +939,94 @@ def _venv_pip_path(runtime_root: Path = NEXO_HOME) -> Path:
     return runtime_root / ".venv" / "bin" / "pip"
 
 
+def _python_version_tuple(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_python_supported(python_bin: Path | str) -> bool:
+    version = _python_version_tuple(python_bin)
+    if not version:
+        return False
+    if desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _resolve_managed_venv_base_python() -> str:
+    candidates = [
+        os.environ.get("NEXO_BOOTSTRAP_PYTHON", ""),
+        os.environ.get("NEXO_RUNTIME_PYTHON", ""),
+        os.environ.get("NEXO_PYTHON", ""),
+    ]
+    if desktop_product_requested():
+        candidates.extend([
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3.12",
+            "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3",
+            "/opt/homebrew/bin/python3.12",
+            "/usr/local/bin/python3.12",
+            shutil.which("python3.12") or "",
+        ])
+    candidates.append(sys.executable)
+    candidates.append(shutil.which("python3") or "")
+    for candidate in candidates:
+        clean = str(candidate or "").strip()
+        if clean and Path(clean).exists() and _managed_venv_python_supported(clean):
+            return clean
+    return sys.executable
+
+
+def _archive_incompatible_runtime_venv(runtime_root: Path = NEXO_HOME, reason: str = "incompatible-python") -> Path | None:
+    venv_dir = runtime_root / ".venv"
+    if not venv_dir.exists():
+        return None
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    backup_root = runtime_root / "runtime" / "backups"
+    try:
+        backup_root.mkdir(parents=True, exist_ok=True)
+        target = backup_root / f"venv-{reason}-{stamp}"
+        counter = 2
+        while target.exists():
+            target = backup_root / f"venv-{reason}-{stamp}-{counter}"
+            counter += 1
+        shutil.move(str(venv_dir), str(target))
+        _log(f"Archived incompatible managed venv at {target}")
+        return target
+    except Exception as exc:
+        _log(f"venv archive failed: {exc}")
+        return None
+
+
 def _ensure_runtime_venv(runtime_root: Path = NEXO_HOME) -> Path | None:
     venv_python = _venv_python_path(runtime_root)
     if venv_python.exists():
-        return venv_python
+        if _managed_venv_python_supported(venv_python):
+            return venv_python
+        version = _python_version_tuple(venv_python)
+        reason = f"python-{'.'.join(map(str, version[:2]))}" if version else "unreadable-python"
+        if _archive_incompatible_runtime_venv(runtime_root, reason=reason) is None:
+            return None
+    base_python = _resolve_managed_venv_base_python()
+    if not _managed_venv_python_supported(base_python):
+        _log(f"no supported base Python found for managed venv: {base_python}")
+        return None
     try:
         runtime_root.mkdir(parents=True, exist_ok=True)
         result = subprocess.run(
-            [sys.executable, "-m", "venv", str(runtime_root / ".venv")],
+            [base_python, "-m", "venv", str(runtime_root / ".venv")],
             capture_output=True,
             text=True,
             timeout=120,
@@ -965,7 +1045,7 @@ def _reinstall_pip_deps() -> bool:
     req_file = SRC_DIR / "requirements.txt"
     if not req_file.exists():
         return True
-    _ensure_runtime_venv(NEXO_HOME)
+    venv_python = _ensure_runtime_venv(NEXO_HOME)
     venv_pip = _venv_pip_path(NEXO_HOME)
     if not venv_pip.exists() and sys.platform != "win32":
         alt_pip = NEXO_HOME / ".venv" / "bin" / "pip3"
@@ -977,11 +1057,14 @@ def _reinstall_pip_deps() -> bool:
                 [str(venv_pip), "install", "--quiet", "-r", str(req_file)],
                 capture_output=True, text=True, timeout=120,
             )
-        else:
+        elif not desktop_product_requested():
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_file), "--break-system-packages"],
                 capture_output=True, text=True, timeout=120,
             )
+        else:
+            _log(f"managed venv unavailable for Desktop dependency repair: {venv_python}")
+            return False
         if result.returncode != 0:
             _log(f"pip install failed (exit {result.returncode}): {result.stderr or result.stdout}")
             return False
@@ -4665,7 +4748,7 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
     req_file = runtime_root / "requirements.txt"
     if not req_file.exists():
         return True
-    _ensure_runtime_venv(runtime_root)
+    venv_python = _ensure_runtime_venv(runtime_root)
     venv_pip = _venv_pip_path(runtime_root)
     if not venv_pip.exists() and sys.platform != "win32":
         alt_pip = runtime_root / ".venv" / "bin" / "pip3"
@@ -4679,13 +4762,16 @@ def _reinstall_runtime_pip_deps(runtime_root: Path = NEXO_HOME) -> bool:
                 text=True,
                 timeout=120,
             )
-        else:
+        elif not desktop_product_requested():
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", "--quiet", "-r", str(req_file), "--break-system-packages"],
                 capture_output=True,
                 text=True,
                 timeout=120,
             )
+        else:
+            _log(f"managed venv unavailable for Desktop runtime dependency repair: {venv_python}")
+            return False
         return result.returncode == 0
     except Exception:
         return False

package/src/cli.py

@@ -1853,6 +1853,42 @@ def _local_context_exclusions(args) -> int:
     return _local_context_emit({"ok": False, "error": f"unsupported exclusions command: {command}"}, args)
 
 
+def _local_context_filetypes(args) -> int:
+    import local_context
+    command = str(getattr(args, "local_context_filetypes_command", "") or "")
+    if command == "list":
+        return _local_context_emit(local_context.list_file_type_rules(readonly=False), args)
+    if command == "include":
+        return _local_context_emit(
+            local_context.set_file_type_rule(
+                getattr(args, "extension", ""),
+                action=getattr(args, "action", "extract") or "extract",
+                reason=getattr(args, "reason", "user") or "user",
+            ),
+            args,
+        )
+    if command == "exclude":
+        return _local_context_emit(
+            local_context.set_file_type_rule(
+                getattr(args, "extension", ""),
+                action="ignore",
+                reason=getattr(args, "reason", "user") or "user",
+            ),
+            args,
+        )
+    if command == "remove":
+        return _local_context_emit(local_context.remove_file_type_rule(getattr(args, "extension", "")), args)
+    if command == "reset":
+        return _local_context_emit(local_context.reset_file_type_rules(), args)
+    return _local_context_emit({"ok": False, "error": f"unsupported filetypes command: {command}"}, args)
+
+
+def _local_context_migrate_roots_v2(args) -> int:
+    import local_context
+    dry_run = not bool(getattr(args, "apply", False))
+    return _local_context_emit(local_context.migrate_roots_seed_v2(dry_run=dry_run), args)
+
+
 def _local_context_query(args) -> int:
     import local_context
     return _local_context_emit(
@@ -3759,6 +3795,29 @@ def main():
     local_context_exclusions_remove_p.add_argument("path", help="Folder path")
     local_context_exclusions_remove_p.add_argument("--json", action="store_true", help="JSON output")
 
+    local_context_filetypes_p = local_context_sub.add_parser("filetypes", help="Manage included and excluded file extensions")
+    local_context_filetypes_sub = local_context_filetypes_p.add_subparsers(dest="local_context_filetypes_command")
+    local_context_filetypes_list_p = local_context_filetypes_sub.add_parser("list", help="List file type rules")
+    local_context_filetypes_list_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_filetypes_include_p = local_context_filetypes_sub.add_parser("include", help="Include a file extension")
+    local_context_filetypes_include_p.add_argument("extension", help="Extension, for example .pdf or asd")
+    local_context_filetypes_include_p.add_argument("--action", choices=["extract", "metadata"], default="extract", help="How to index this extension")
+    local_context_filetypes_include_p.add_argument("--reason", default="user", help="Reason label")
+    local_context_filetypes_include_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_filetypes_exclude_p = local_context_filetypes_sub.add_parser("exclude", help="Exclude a file extension")
+    local_context_filetypes_exclude_p.add_argument("extension", help="Extension, for example .jpg or tmp")
+    local_context_filetypes_exclude_p.add_argument("--reason", default="user", help="Reason label")
+    local_context_filetypes_exclude_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_filetypes_remove_p = local_context_filetypes_sub.add_parser("remove", help="Remove a user extension override")
+    local_context_filetypes_remove_p.add_argument("extension", help="Extension to reset")
+    local_context_filetypes_remove_p.add_argument("--json", action="store_true", help="JSON output")
+    local_context_filetypes_reset_p = local_context_filetypes_sub.add_parser("reset", help="Remove all user extension overrides")
+    local_context_filetypes_reset_p.add_argument("--json", action="store_true", help="JSON output")
+
+    local_context_migrate_roots_v2_p = local_context_sub.add_parser("migrate-roots-v2", help="Plan or apply Local Memory roots v2 cleanup")
+    local_context_migrate_roots_v2_p.add_argument("--apply", action="store_true", help="Apply cleanup. Omit for dry-run.")
+    local_context_migrate_roots_v2_p.add_argument("--json", action="store_true", help="JSON output")
+
     local_context_query_p = local_context_sub.add_parser("query", help="Query local memory evidence")
     local_context_query_p.add_argument("query", help="Question or search phrase")
     local_context_query_p.add_argument("--intent", default="answer", help="Intent label included with the query result")
@@ -4407,6 +4466,13 @@ def main():
                 local_context_exclusions_p.print_help()
                 return 0
             return _local_context_exclusions(args)
+        if args.local_context_command == "filetypes":
+            if not args.local_context_filetypes_command:
+                local_context_filetypes_p.print_help()
+                return 0
+            return _local_context_filetypes(args)
+        if args.local_context_command == "migrate-roots-v2":
+            return _local_context_migrate_roots_v2(args)
         if args.local_context_command == "query":
             return _local_context_query(args)
         if args.local_context_command == "diagnostics":

package/src/db/_schema.py

@@ -1775,6 +1775,9 @@ def _m63_local_context_layer(conn):
             display_path TEXT NOT NULL,
             mode TEXT NOT NULL DEFAULT 'normal',
             depth INTEGER NOT NULL DEFAULT 2,
+            source TEXT NOT NULL DEFAULT 'user',
+            remote INTEGER NOT NULL DEFAULT 0,
+            seed_version INTEGER NOT NULL DEFAULT 1,
             status TEXT NOT NULL DEFAULT 'active',
             last_scan_at REAL,
             created_at REAL NOT NULL,
@@ -1785,10 +1788,24 @@ def _m63_local_context_layer(conn):
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             path TEXT NOT NULL UNIQUE,
             display_path TEXT NOT NULL,
+            source TEXT NOT NULL DEFAULT 'user',
+            kind TEXT NOT NULL DEFAULT 'folder',
             reason TEXT NOT NULL DEFAULT 'user',
             created_at REAL NOT NULL
         );
 
+        CREATE TABLE IF NOT EXISTS local_index_file_type_rules (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            extension TEXT NOT NULL,
+            action TEXT NOT NULL DEFAULT 'ignore',
+            source TEXT NOT NULL DEFAULT 'user',
+            priority INTEGER NOT NULL DEFAULT 0,
+            reason TEXT NOT NULL DEFAULT '',
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL,
+            UNIQUE(extension, source)
+        );
+
         CREATE TABLE IF NOT EXISTS local_index_jobs (
             job_id TEXT PRIMARY KEY,
             asset_id TEXT NOT NULL,
@@ -1940,6 +1957,12 @@ def _m63_local_context_layer(conn):
 
         CREATE INDEX IF NOT EXISTS idx_local_index_roots_status
             ON local_index_roots(status);
+        CREATE INDEX IF NOT EXISTS idx_local_index_roots_source
+            ON local_index_roots(source, status);
+        CREATE INDEX IF NOT EXISTS idx_local_index_exclusions_source
+            ON local_index_exclusions(source);
+        CREATE INDEX IF NOT EXISTS idx_local_index_file_type_rules_ext
+            ON local_index_file_type_rules(extension, source);
         CREATE INDEX IF NOT EXISTS idx_local_index_jobs_status_priority
             ON local_index_jobs(status, priority, created_at);
         CREATE INDEX IF NOT EXISTS idx_local_index_jobs_asset

package/src/doctor/providers/boot.py

@@ -549,6 +549,111 @@ def check_python_runtime() -> DoctorCheck:
     )
 
 
+def _desktop_product_requested() -> bool:
+    try:
+        from product_mode import desktop_product_requested
+        return bool(desktop_product_requested())
+    except Exception:
+        return str(os.environ.get("NEXO_DESKTOP_MANAGED", "")).strip() == "1"
+
+
+def _managed_venv_python_path() -> Path:
+    if sys.platform == "win32":
+        return NEXO_HOME / ".venv" / "Scripts" / "python.exe"
+    return NEXO_HOME / ".venv" / "bin" / "python3"
+
+
+def _probe_python_version(python_bin: Path | str) -> tuple[int, int, int] | None:
+    try:
+        result = subprocess.run(
+            [str(python_bin), "-c", "import sys; print('.'.join(map(str, sys.version_info[:3])))"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except Exception:
+        return None
+    if result.returncode != 0:
+        return None
+    import re
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", result.stdout or result.stderr or "")
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2)), int(match.group(3))
+
+
+def _managed_venv_version_supported(version: tuple[int, int, int] | None) -> bool:
+    if not version:
+        return False
+    if _desktop_product_requested():
+        return version[:2] == (3, 12)
+    return version >= (3, 10, 0)
+
+
+def _repair_managed_venv_python() -> bool:
+    try:
+        import auto_update
+        return bool(auto_update._ensure_runtime_venv(NEXO_HOME)) and bool(auto_update._reinstall_pip_deps())
+    except Exception:
+        return False
+
+
+def check_managed_venv_python(fix: bool = False) -> DoctorCheck:
+    """Check the managed NEXO venv is compatible with bundled runtime deps."""
+    venv_python = _managed_venv_python_path()
+    if not venv_python.exists():
+        if not _desktop_product_requested():
+            return DoctorCheck(
+                id="boot.managed_venv_python",
+                tier="boot",
+                status="healthy",
+                severity="info",
+                summary="Managed Python venv not present yet",
+                evidence=[str(venv_python)],
+            )
+        return DoctorCheck(
+            id="boot.managed_venv_python",
+            tier="boot",
+            status="degraded",
+            severity="warn",
+            summary="Managed Python venv missing",
+            evidence=[str(venv_python)],
+            repair_plan=["Run nexo doctor --tier boot --fix or nexo update to recreate the managed venv"],
+        )
+
+    version = _probe_python_version(venv_python)
+    if _managed_venv_version_supported(version):
+        return DoctorCheck(
+            id="boot.managed_venv_python",
+            tier="boot",
+            status="healthy",
+            severity="info",
+            summary=f"Managed venv Python {'.'.join(map(str, version))}",
+            evidence=[str(venv_python)],
+        )
+
+    summary = "Managed venv Python is incompatible"
+    if version:
+        summary = f"Managed venv Python {'.'.join(map(str, version))} is incompatible"
+    if _desktop_product_requested():
+        summary += " — Desktop bundled wheels require Python 3.12"
+    if fix and _repair_managed_venv_python():
+        post = check_managed_venv_python(fix=False)
+        if post.status == "healthy":
+            post.fixed = True
+            post.summary += " (fixed)"
+            return post
+    return DoctorCheck(
+        id="boot.managed_venv_python",
+        tier="boot",
+        status="degraded",
+        severity="warn",
+        summary=summary,
+        evidence=[str(venv_python)],
+        repair_plan=["Run nexo doctor --tier boot --fix or nexo update to archive and recreate the managed venv"],
+    )
+
+
 CRITICAL_CONFIG_FILES = (
     ("schedule.json", ("config", "schedule.json")),
     ("optionals.json", ("config", "optionals.json")),
@@ -803,6 +908,7 @@ def run_boot_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_disk_space),
         safe_check(check_wrapper_scripts),
         safe_check(check_python_runtime),
+        safe_check(check_managed_venv_python, fix=fix),
         safe_check(check_config_parse),
         safe_check(check_core_dev_packaged_install),
         safe_check(check_dashboard_desktop_contract),

package/src/local_context/__init__.py

@@ -17,17 +17,22 @@ from .api import (
     get_asset,
     get_neighbors,
     list_exclusions,
+    list_file_type_rules,
     list_roots,
     local_index_hygiene,
+    migrate_roots_seed_v2,
     model_status,
     pause,
     performance_config,
     purge_asset,
     reconcile_live_changes,
     remove_exclusion,
+    remove_file_type_rule,
     remove_root,
+    reset_file_type_rules,
     resume,
     run_once,
+    set_file_type_rule,
     set_performance_profile,
     status,
     warmup_models,
@@ -45,17 +50,22 @@ __all__ = [
     "get_asset",
     "get_neighbors",
     "list_exclusions",
+    "list_file_type_rules",
     "list_roots",
     "local_index_hygiene",
+    "migrate_roots_seed_v2",
     "model_status",
     "pause",
     "performance_config",
     "purge_asset",
     "reconcile_live_changes",
     "remove_exclusion",
+    "remove_file_type_rule",
     "remove_root",
+    "reset_file_type_rules",
     "resume",
     "run_once",
+    "set_file_type_rule",
     "set_performance_profile",
     "status",
     "warmup_models",