nexo-brain 7.9.19 → 7.9.21

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.19",
+  "version": "7.9.21",
   "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.9.19` is the current packaged-runtime line. Patch release over `7.9.18`: runtime doctor now distinguishes real install breakage from tracked in-progress work, interactive Desktop sessions no longer poison automation telemetry scoring, stale filesystem skill rows are pruned during sync, stale protocol debt draining marks rows resolved, and watchdog treats LaunchAgent SIGTERM reloads as supervisor interruptions instead of failures. It includes the v7.9.18 client-sync bootstrap fix.
+Version `7.9.21` is the current packaged-runtime line. Patch release over `7.9.20`: LaunchAgent reload/repair now handles macOS already-loaded races by booting out jobs with modern launchctl forms, falling back to legacy load, and treating an already-loaded job as healthy only when it points at the expected plist.
+
+Previously in `7.9.20`: packaged update/doctor repair now finds `runtime/crons/sync.py`, LaunchAgent PATH includes the managed Claude runtime installed under `~/.nexo/runtime/bootstrap/npm-global/bin`, root runtime backfill includes `claude_cli.py`, and Immune no longer treats the legacy optional `~/.claude-mem/claude-mem.db` as a required database.
+
+Previously in `7.9.19`: runtime doctor now distinguishes real install breakage from tracked in-progress work, interactive Desktop sessions no longer poison automation telemetry scoring, stale filesystem skill rows are pruned during sync, stale protocol debt draining marks rows resolved, and watchdog treats LaunchAgent SIGTERM reloads as supervisor interruptions instead of failures.
 
 Previously in `7.9.18`: packaged client-sync imports now work when `NEXO_HOME` is unset, so `nexo clients sync`, `nexo update`, and runtime doctor bootstrap checks no longer hit the `_user_home` import-order crash.
 

package/package.json

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

@@ -1267,26 +1267,15 @@ def _reload_launch_agents_after_bump() -> dict:
             if not plist.is_file():
                 result["skipped_missing"] += 1
                 continue
-            # launchctl bootout / bootstrap is the modern API but requires
-            # the GUI session id ($UID/Background or gui/$UID). The legacy
-            # unload + load -w pair still works on every macOS NEXO supports
-            # and does not need a session id, so we use it here.
-            unload_proc = subprocess.run(
-                ["launchctl", "unload", str(plist)],
-                capture_output=True, text=True, timeout=10,
-            )
-            # unload returns non-zero if the agent was not loaded — that
-            # is fine, we still try to load fresh.
-            load_proc = subprocess.run(
-                ["launchctl", "load", "-w", str(plist)],
-                capture_output=True, text=True, timeout=10,
-            )
-            if load_proc.returncode == 0:
+            from runtime_power import reload_launchagent_plist
+
+            reload_result = reload_launchagent_plist(plist)
+            if reload_result.get("ok"):
                 result["reloaded"] += 1
             else:
                 result["errors"].append({
                     "plist": plist.name,
-                    "stderr": (load_proc.stderr or load_proc.stdout or "load failed")[:300],
+                    "stderr": str(reload_result.get("error") or "reload failed")[:300],
                 })
         except subprocess.TimeoutExpired:
             result["errors"].append({"plist": plist.name, "stderr": "launchctl timeout"})
@@ -3816,7 +3805,7 @@ def _auto_update_check_locked() -> dict:
 
     # Backfill runtime CLI modules for existing installs
     try:
-        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "agent_runner.py", "bootstrap_docs.py"):
+        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "claude_cli.py", "agent_runner.py", "bootstrap_docs.py"):
             src_file = SRC_DIR / fname
             dest_file = NEXO_HOME / fname
             if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):

package/src/crons/sync.py

@@ -34,13 +34,24 @@ if str(_runtime_root) not in sys.path:
 import paths
 from cron_recovery import is_cron_enabled, resolve_declared_schedule, should_run_at_load
 try:
-    from runtime_power import resolve_launchagent_path
+    from runtime_power import (
+        reload_launchagent_plist,
+        resolve_launchagent_path,
+        unload_launchagent_plist,
+    )
 except ImportError:
     def resolve_launchagent_path() -> str:
         """Fallback when runtime_power is not importable."""
         home = Path.home()
-        parts = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin",
-                 str(home / ".local/bin"), str(home / ".nexo/bin")]
+        parts = [
+            str(home / ".nexo/runtime/bootstrap/npm-global/bin"),
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin",
+            "/bin",
+            str(home / ".local/bin"),
+            str(home / ".nexo/bin"),
+        ]
         nvm_dir = home / ".nvm/versions/node"
         if nvm_dir.is_dir():
             versions = sorted(nvm_dir.iterdir(), key=lambda p: p.stat().st_mtime, reverse=True)
@@ -51,6 +62,17 @@ except ImportError:
                     break
         return ":".join(parts)
 
+    def reload_launchagent_plist(plist_path: Path, label: str | None = None, timeout: int = 10) -> dict:
+        subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+        proc = subprocess.run(["launchctl", "load", "-w", str(plist_path)], capture_output=True, text=True, timeout=timeout)
+        if proc.returncode == 0:
+            return {"ok": True, "label": label or Path(plist_path).stem}
+        return {"ok": False, "label": label or Path(plist_path).stem, "error": proc.stderr or proc.stdout or "load failed"}
+
+    def unload_launchagent_plist(plist_path: Path, label: str | None = None, timeout: int = 10) -> dict:
+        proc = subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True, text=True, timeout=timeout)
+        return {"ok": proc.returncode == 0, "label": label or Path(plist_path).stem}
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 SOURCE_ROOT = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent.parent)))
 RUNTIME_ROOT = NEXO_HOME
@@ -430,14 +452,14 @@ def install_plist(label: str, plist: dict, plist_path: Path, dry_run: bool):
         log(f"  DRY-RUN: would install {plist_path.name}")
         return
 
-    # Unload if already loaded
-    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
-
     with open(plist_path, "wb") as f:
         plistlib.dump(plist, f)
 
-    subprocess.run(["launchctl", "load", str(plist_path)], capture_output=True)
-    log(f"  Installed + loaded: {plist_path.name}")
+    result = reload_launchagent_plist(plist_path, label=label)
+    if result.get("ok"):
+        log(f"  Installed + loaded: {plist_path.name}")
+    else:
+        log(f"  Installed but launchctl reload failed: {plist_path.name}: {result.get('error') or 'unknown error'}")
 
 
 def unload_plist(plist_path: Path, dry_run: bool):
@@ -446,7 +468,7 @@ def unload_plist(plist_path: Path, dry_run: bool):
         log(f"  DRY-RUN: would remove {plist_path.name}")
         return
 
-    subprocess.run(["launchctl", "unload", str(plist_path)], capture_output=True)
+    unload_launchagent_plist(plist_path)
     plist_path.unlink(missing_ok=True)
     log(f"  Removed: {plist_path.name}")
 

package/src/doctor/providers/runtime.py

@@ -32,6 +32,7 @@ from claude_cli import (
 )
 from cron_recovery import is_cron_enabled, resolve_declared_schedule, should_run_at_load
 from doctor.models import DoctorCheck, safe_check
+from runtime_power import reload_launchagent_plist
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
@@ -1080,25 +1081,13 @@ def _recent_permission_denial(cron_id: str, max_age_seconds: int = 7 * 86400) ->
 
 def _repair_launchagents(items: list[tuple[str, Path]]) -> tuple[bool, list[str]]:
     evidence = []
-    uid = str(os.getuid())
     ok = True
     for cron_id, plist_path in items:
         label = f"com.nexo.{cron_id}"
-        subprocess.run(
-            ["launchctl", "bootout", f"gui/{uid}/{label}"],
-            capture_output=True,
-            text=True,
-            timeout=3,
-        )
-        result = subprocess.run(
-            ["launchctl", "bootstrap", f"gui/{uid}", str(plist_path)],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        if result.returncode != 0:
+        result = reload_launchagent_plist(plist_path, label=label, timeout=5)
+        if not result.get("ok"):
             ok = False
-            evidence.append(f"{label}: {result.stderr.strip() or result.stdout.strip() or 'bootstrap failed'}")
+            evidence.append(f"{label}: {result.get('error') or result.get('bootstrap_error') or 'reload failed'}")
     return ok, evidence
 
 
@@ -1131,17 +1120,20 @@ def _repair_special_launchagent_plists(items: list[tuple[str, Path]]) -> tuple[b
 
 
 def _sync_launchagents_from_manifest() -> tuple[bool, list[str]]:
-    sync_path = NEXO_CODE / "crons" / "sync.py"
+    sync_path = paths.crons_dir() / "sync.py"
+    if not sync_path.is_file():
+        sync_path = NEXO_CODE / "crons" / "sync.py"
     if not sync_path.is_file():
         return False, [f"cron sync script not found at {sync_path}"]
 
     try:
+        runtime_code = paths.core_dir()
         result = subprocess.run(
             [sys.executable, str(sync_path)],
             capture_output=True,
             text=True,
             timeout=30,
-            env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(NEXO_CODE)},
+            env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(runtime_code)},
         )
     except Exception as e:
         return False, [f"cron sync failed: {e}"]

package/src/plugins/update.py

@@ -1043,25 +1043,16 @@ def _reload_launch_agents_after_bump() -> dict:
             if not plist.is_file():
                 result["skipped_missing"] += 1
                 continue
-            subprocess.run(
-                ["launchctl", "unload", str(plist)],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            load_proc = subprocess.run(
-                ["launchctl", "load", "-w", str(plist)],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if load_proc.returncode == 0:
+            from runtime_power import reload_launchagent_plist
+
+            reload_result = reload_launchagent_plist(plist)
+            if reload_result.get("ok"):
                 result["reloaded"] += 1
             else:
                 result["errors"].append(
                     {
                         "plist": plist.name,
-                        "stderr": (load_proc.stderr or load_proc.stdout or "load failed")[:300],
+                        "stderr": str(reload_result.get("error") or "reload failed")[:300],
                     }
                 )
         except subprocess.TimeoutExpired:

package/src/runtime_power.py

@@ -17,9 +17,11 @@ import json
 import os
 import paths
 import platform
+import plistlib
 import shutil
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 
@@ -80,8 +82,15 @@ DEFAULT_CODEX_REASONING_EFFORT = _CODEX_DEFAULTS["reasoning_effort"]
 def resolve_launchagent_path() -> str:
     """Build a PATH string for LaunchAgent plists that includes nvm node if present."""
     home = Path.home()
-    parts = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin",
-             str(home / ".local/bin"), str(home / ".nexo/bin")]
+    parts = [
+        str(home / ".nexo/runtime/bootstrap/npm-global/bin"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        "/usr/bin",
+        "/bin",
+        str(home / ".local/bin"),
+        str(home / ".nexo/bin"),
+    ]
     # Detect nvm node
     nvm_dir = home / ".nvm/versions/node"
     if nvm_dir.is_dir():
@@ -94,6 +103,163 @@ def resolve_launchagent_path() -> str:
     return ":".join(parts)
 
 
+def launchagent_label_from_plist(plist_path: Path, label: str | None = None) -> str:
+    """Resolve a launchd label from a plist, falling back to the filename."""
+    if label:
+        return label
+    try:
+        with Path(plist_path).open("rb") as fh:
+            payload = plistlib.load(fh)
+        plist_label = payload.get("Label")
+        if plist_label:
+            return str(plist_label)
+    except Exception:
+        pass
+    name = Path(plist_path).stem
+    return name
+
+
+def _launchctl_text(proc: subprocess.CompletedProcess) -> str:
+    return (proc.stderr or proc.stdout or "").strip()
+
+
+def _launchctl_print(label: str, timeout: int = 5) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["launchctl", "print", f"gui/{os.getuid()}/{label}"],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+def launchagent_loaded_from_plist(plist_path: Path, label: str | None = None) -> bool:
+    """Return True when launchd has the label loaded from this exact plist."""
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    try:
+        proc = _launchctl_print(resolved_label)
+    except Exception:
+        return False
+    if proc.returncode != 0:
+        return False
+    stdout = proc.stdout or ""
+    candidates = {
+        str(plist_path),
+        str(plist_path.expanduser()),
+        str(plist_path.resolve(strict=False)),
+    }
+    return any(f"path = {candidate}" in stdout or candidate in stdout for candidate in candidates)
+
+
+def unload_launchagent_plist(
+    plist_path: Path,
+    label: str | None = None,
+    timeout: int = 10,
+    wait_seconds: float = 0.25,
+) -> dict:
+    """Best-effort unload using modern and legacy launchctl forms.
+
+    macOS can report a generic bootstrap error when a job is still loaded.
+    We therefore boot out by label, boot out by plist path, and finally call
+    the legacy unload form for older installs.
+    """
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    domain = f"gui/{os.getuid()}"
+    commands = [
+        ["launchctl", "bootout", f"{domain}/{resolved_label}"],
+        ["launchctl", "bootout", domain, str(plist_path)],
+        ["launchctl", "unload", str(plist_path)],
+    ]
+    evidence: list[str] = []
+    for command in commands:
+        try:
+            proc = subprocess.run(command, capture_output=True, text=True, timeout=timeout)
+            if proc.returncode != 0:
+                text = _launchctl_text(proc)
+                if text:
+                    evidence.append(text[:300])
+        except subprocess.TimeoutExpired:
+            evidence.append("launchctl timeout")
+        except Exception as exc:
+            evidence.append(str(exc)[:300])
+
+    deadline = time.monotonic() + max(0.0, wait_seconds)
+    while time.monotonic() < deadline:
+        if not launchagent_loaded_from_plist(plist_path, resolved_label):
+            return {"ok": True, "label": resolved_label, "errors": evidence}
+        time.sleep(0.05)
+
+    still_loaded = launchagent_loaded_from_plist(plist_path, resolved_label)
+    return {"ok": not still_loaded, "label": resolved_label, "errors": evidence}
+
+
+def reload_launchagent_plist(
+    plist_path: Path,
+    label: str | None = None,
+    timeout: int = 10,
+) -> dict:
+    """Reload one LaunchAgent and tolerate already-loaded launchd races."""
+    plist_path = Path(plist_path)
+    resolved_label = launchagent_label_from_plist(plist_path, label)
+    if not plist_path.is_file():
+        return {"ok": False, "label": resolved_label, "error": "plist missing"}
+
+    unload_launchagent_plist(plist_path, resolved_label, timeout=timeout)
+    domain = f"gui/{os.getuid()}"
+    try:
+        bootstrap = subprocess.run(
+            ["launchctl", "bootstrap", domain, str(plist_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "label": resolved_label, "error": "launchctl timeout"}
+    except Exception as exc:
+        return {"ok": False, "label": resolved_label, "error": str(exc)[:300]}
+
+    if bootstrap.returncode == 0:
+        return {"ok": True, "label": resolved_label, "action": "bootstrap"}
+
+    bootstrap_error = _launchctl_text(bootstrap) or "bootstrap failed"
+    if launchagent_loaded_from_plist(plist_path, resolved_label):
+        return {
+            "ok": True,
+            "label": resolved_label,
+            "action": "already-loaded",
+            "warning": bootstrap_error[:300],
+        }
+
+    try:
+        fallback = subprocess.run(
+            ["launchctl", "load", "-w", str(plist_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return {"ok": False, "label": resolved_label, "error": "launchctl timeout"}
+    except Exception as exc:
+        return {"ok": False, "label": resolved_label, "error": str(exc)[:300]}
+
+    if fallback.returncode == 0 or launchagent_loaded_from_plist(plist_path, resolved_label):
+        return {
+            "ok": True,
+            "label": resolved_label,
+            "action": "legacy-load",
+            "warning": bootstrap_error[:300],
+        }
+
+    fallback_error = _launchctl_text(fallback) or "load failed"
+    return {
+        "ok": False,
+        "label": resolved_label,
+        "error": fallback_error[:300],
+        "bootstrap_error": bootstrap_error[:300],
+    }
+
+
 def _schedule_defaults() -> dict:
     return {
         "timezone": "UTC",

package/src/scripts/nexo-immune.py

@@ -367,8 +367,9 @@ def check_databases():
     dbs = [
         ("nexo.db", paths.db_path()),
         ("cognitive.db", paths.data_dir() / "cognitive.db"),
-        ("claude-mem.db", CLAUDE_MEM_DB),
     ]
+    if CLAUDE_MEM_DB.exists():
+        dbs.append(("claude-mem.db", CLAUDE_MEM_DB))
 
     for name, path in dbs:
         result = {"name": name, "status": "OK", "detail": ""}