nexo-brain 7.9.10 → 7.9.12

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.10",
+  "version": "7.9.12",
   "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,7 @@
 
 [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.10` is the current packaged-runtime line. Hotfix release over `7.9.9`: `nexo_doctor` now defaults blank calls to `runtime_personal` instead of failing on missing `plane`, and non-interactive installer/update paths preserve existing identity defaults from runtime profile/calibration metadata instead of blindly rewriting operators to generic onboarding defaults. Desktop remains at v0.28.11 because the extra fixes are Brain-only.
+Version `7.9.12` is the current packaged-runtime line. Patch release over `7.9.11`: managed `~/.nexo/bin/nexo` wrappers now self-repair `core/current` when it lags behind `~/.nexo/core`, so installed users stop executing stale snapshots and `nexo update` no longer gets stuck claiming “Already up to date” from the old runtime. Coordinated Desktop release: v0.28.13.
 
 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.
 

package/bin/nexo-brain.js

@@ -3442,6 +3442,31 @@ async function runSetup() {
     '  echo "NEXO runtime Python not found. Run nexo-brain or nexo update to repair the installation." >&2',
     '  exit 1',
     'fi',
+    'read_runtime_version() {',
+    '  local base="${1:-}"',
+    '  [ -n "$base" ] || return 0',
+    '  local candidate=""',
+    '  for candidate in "$base/version.json" "$base/package.json"; do',
+    '    [ -f "$candidate" ] || continue',
+    '    "$PYTHON" -c "import json, sys; from pathlib import Path; payload=json.loads(Path(sys.argv[1]).read_text(encoding=\\"utf-8\\")); version=str(payload.get(\\"version\\", \\"\\")).strip(); sys.stdout.write(version); sys.exit(0 if version else 1)" "$candidate" 2>/dev/null || continue',
+    '    return 0',
+    '  done',
+    '  return 0',
+    '}',
+    'repair_stale_current_runtime() {',
+    '  local core_root="$NEXO_HOME/core"',
+    '  local current_root="$NEXO_HOME/core/current"',
+    '  [ -d "$core_root" ] || return 0',
+    '  [ -e "$current_root" ] || return 0',
+    '  local core_version=""',
+    '  local current_version=""',
+    '  core_version="$(read_runtime_version "$core_root")"',
+    '  current_version="$(read_runtime_version "$current_root")"',
+    '  [ -n "$core_version" ] || return 0',
+    '  [ "$core_version" = "$current_version" ] && return 0',
+    '  NEXO_HOME="$NEXO_HOME" NEXO_CODE="$core_root" "$PYTHON" -c "import os, sys; from pathlib import Path; home=Path(os.environ[\\"NEXO_HOME\\"]); core=home / \\"core\\"; sys.path.insert(0, str(core)); from runtime_versioning import activate_versioned_runtime_snapshot, read_version_for_path; version=read_version_for_path(core); result=activate_versioned_runtime_snapshot(source_root=core, version=str(version or \\"\\").strip()); sys.exit(0 if result.get(\\"ok\\") else 1)" >/dev/null 2>&1 || return 0',
+    '}',
+    'repair_stale_current_runtime',
     'CLI_PY="$NEXO_CODE/cli.py"',
     'if [ ! -f "$CLI_PY" ] && [ -f "$NEXO_HOME/core/current/cli.py" ]; then',
     '  NEXO_CODE="$NEXO_HOME/core/current"',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.9.10",
+  "version": "7.9.12",
   "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/agent_runner.py

@@ -792,6 +792,8 @@ def _build_enforcement_system_prompt() -> str:
     map_path = NEXO_HOME / "tool-enforcement-map.json"
     if not map_path.exists():
         for candidate in [
+            # .resolve() handles the $NEXO_HOME symlink -> core/ case.
+            Path(__file__).resolve().parent / "tool-enforcement-map.json",
             Path(__file__).parent / "tool-enforcement-map.json",
             Path(__file__).parent.parent / "tool-enforcement-map.json",
         ]:

package/src/auto_update.py

@@ -593,6 +593,31 @@ def _runtime_cli_wrapper_text() -> str:
         '  echo "NEXO runtime Python not found. Run nexo-brain or nexo update to repair the installation." >&2\n'
         '  exit 1\n'
         'fi\n'
+        'read_runtime_version() {\n'
+        '  local base="${1:-}"\n'
+        '  [ -n "$base" ] || return 0\n'
+        '  local candidate=""\n'
+        '  for candidate in "$base/version.json" "$base/package.json"; do\n'
+        '    [ -f "$candidate" ] || continue\n'
+        '    "$PYTHON" -c "import json, sys; from pathlib import Path; payload=json.loads(Path(sys.argv[1]).read_text(encoding=\\"utf-8\\")); version=str(payload.get(\\"version\\", \\"\\")).strip(); sys.stdout.write(version); sys.exit(0 if version else 1)" "$candidate" 2>/dev/null || continue\n'
+        '    return 0\n'
+        '  done\n'
+        '  return 0\n'
+        '}\n'
+        'repair_stale_current_runtime() {\n'
+        '  local core_root="$NEXO_HOME/core"\n'
+        '  local current_root="$NEXO_HOME/core/current"\n'
+        '  [ -d "$core_root" ] || return 0\n'
+        '  [ -e "$current_root" ] || return 0\n'
+        '  local core_version=""\n'
+        '  local current_version=""\n'
+        '  core_version="$(read_runtime_version "$core_root")"\n'
+        '  current_version="$(read_runtime_version "$current_root")"\n'
+        '  [ -n "$core_version" ] || return 0\n'
+        '  [ "$core_version" = "$current_version" ] && return 0\n'
+        '  NEXO_HOME="$NEXO_HOME" NEXO_CODE="$core_root" "$PYTHON" -c "import os, sys; from pathlib import Path; home=Path(os.environ[\\"NEXO_HOME\\"]); core=home / \\"core\\"; sys.path.insert(0, str(core)); from runtime_versioning import activate_versioned_runtime_snapshot, read_version_for_path; version=read_version_for_path(core); result=activate_versioned_runtime_snapshot(source_root=core, version=str(version or \\"\\").strip()); sys.exit(0 if result.get(\\"ok\\") else 1)" >/dev/null 2>&1 || return 0\n'
+        '}\n'
+        'repair_stale_current_runtime\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'

package/src/cli.py

@@ -3232,6 +3232,20 @@ def main():
     lwait_p.add_argument("--timeout-ms", type=int, default=45_000)
     lwait_p.add_argument("--poll-ms", type=int, default=500)
 
+    lwait_stop_p = lifecycle_sub.add_parser(
+        "wait-for-stop",
+        help="v7.9.10: wait until the linked NEXO session is no longer active",
+    )
+    lwait_stop_p.add_argument("--event-id", required=True)
+    lwait_stop_p.add_argument("--timeout-ms", type=int, default=10_000)
+    lwait_stop_p.add_argument("--poll-ms", type=int, default=500)
+
+    lstop_sid_p = lifecycle_sub.add_parser(
+        "stop-nexo-session",
+        help="v7.9.10: explicit best-effort stop of a NEXO SID for Desktop lifecycle cleanup",
+    )
+    lstop_sid_p.add_argument("--sid", required=True)
+
     # Fase E.5 — quarantine ops surfaced via Desktop Guardian Proposals panel.
     quarantine_parser = sub.add_parser("quarantine", help="Quarantine proposals (Fase E.5 Desktop UI)")
     quarantine_sub = quarantine_parser.add_subparsers(dest="quarantine_command")
@@ -3533,6 +3547,38 @@ def main():
             if status == "retryable_error":
                 return 2
             return 3
+        if args.lifecycle_command == "wait-for-stop":
+            out = _lifecycle_plugin.handle_nexo_lifecycle_wait_for_stop(
+                event_id=args.event_id,
+                timeout_ms=args.timeout_ms,
+                poll_ms=args.poll_ms,
+            )
+            print(out)
+            try:
+                parsed = _json.loads(out)
+                status = str(parsed.get("status", ""))
+            except Exception:
+                status = ""
+            if status == "ok":
+                return 0
+            if status == "retryable_error":
+                return 2
+            return 3
+        if args.lifecycle_command == "stop-nexo-session":
+            out = _lifecycle_plugin.handle_nexo_lifecycle_stop_nexo_session(
+                sid=args.sid,
+            )
+            print(out)
+            try:
+                parsed = _json.loads(out)
+                status = str(parsed.get("status", ""))
+            except Exception:
+                status = ""
+            if status == "ok":
+                return 0
+            if status == "retryable_error":
+                return 2
+            return 3
         lifecycle_parser.print_help()
         return 1
     elif args.command in ("schema", "identity", "onboard", "scan-profile"):

package/src/enforcement_engine.py

@@ -321,7 +321,13 @@ def _redact_for_log(text: str, max_len: int = 200) -> str:
 
 
 def _load_map() -> dict | None:
+    # .resolve() is required: at runtime this module is usually imported via
+    # the symlink $NEXO_HOME/enforcement_engine.py -> core/enforcement_engine.py,
+    # so the non-resolved Path(__file__).parent points at NEXO_HOME instead
+    # of the core/ dir where the map actually sits. Keeping the non-resolved
+    # variant too covers in-repo test imports.
     for candidate in [
+        Path(__file__).resolve().parent / MAP_FILENAME,
         Path(__file__).parent / MAP_FILENAME,
         paths.home() / MAP_FILENAME,
         paths.brain_dir() / MAP_FILENAME,

package/src/lifecycle_events.py

@@ -55,6 +55,7 @@ import time
 from typing import Any, Dict, List, Optional
 
 from db import get_db
+from db._core import SESSION_STALE_SECONDS
 import lifecycle_prompts
 
 
@@ -259,6 +260,103 @@ def _session_diary_since(conn, session_id: str, dispatched_at: Optional[str], ac
     return _session_diary_evidence(conn, session_id, dispatched_at, actions_json) is not None
 
 
+def _session_stop_state(conn, session_id: str) -> Dict[str, Any]:
+    """Return whether the lifecycle session can be verified as fully stopped."""
+    raw = str(session_id or "").strip()
+    if not raw:
+        return {
+            "verifiable": False,
+            "session_registered": False,
+            "stop_confirmed": False,
+            "active_session_ids": [],
+        }
+
+    candidate_ids: List[str] = []
+    verifiable = False
+
+    if raw.startswith("nexo-"):
+        candidate_ids.append(raw)
+        verifiable = True
+
+    try:
+        rows = conn.execute(
+            "SELECT sid FROM session_claude_aliases "
+            "WHERE claude_session_id = ? ORDER BY last_seen DESC",
+            (raw,),
+        ).fetchall()
+        alias_ids = [str(row[0]) for row in rows if row and row[0]]
+        if alias_ids:
+            candidate_ids.extend(alias_ids)
+            verifiable = True
+    except Exception:
+        pass
+
+    try:
+        rows = conn.execute(
+            "SELECT sid FROM sessions "
+            "WHERE external_session_id = ? OR claude_session_id = ? OR sid = ? "
+            "ORDER BY last_update_epoch DESC",
+            (raw, raw, raw),
+        ).fetchall()
+        live_ids = [str(row[0]) for row in rows if row and row[0]]
+        if live_ids:
+            candidate_ids.extend(live_ids)
+            verifiable = True
+    except Exception:
+        pass
+
+    deduped_candidates: List[str] = []
+    seen = set()
+    for sid in candidate_ids:
+        if sid and sid not in seen:
+            seen.add(sid)
+            deduped_candidates.append(sid)
+
+    if not verifiable:
+        return {
+            "verifiable": False,
+            "session_registered": False,
+            "stop_confirmed": False,
+            "active_session_ids": [],
+        }
+
+    cutoff = time.time() - float(SESSION_STALE_SECONDS)
+    active_ids: List[str] = []
+    try:
+        if deduped_candidates:
+            placeholders = ",".join("?" for _ in deduped_candidates)
+            rows = conn.execute(
+                "SELECT sid FROM sessions "
+                f"WHERE last_update_epoch > ? AND (sid IN ({placeholders}) OR external_session_id = ? OR claude_session_id = ?) "
+                "ORDER BY last_update_epoch DESC",
+                (cutoff, *deduped_candidates, raw, raw),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                "SELECT sid FROM sessions "
+                "WHERE last_update_epoch > ? AND (external_session_id = ? OR claude_session_id = ?) "
+                "ORDER BY last_update_epoch DESC",
+                (cutoff, raw, raw),
+            ).fetchall()
+        active_ids = [str(row[0]) for row in rows if row and row[0]]
+    except Exception:
+        active_ids = []
+
+    deduped_active: List[str] = []
+    seen.clear()
+    for sid in active_ids:
+        if sid and sid not in seen:
+            seen.add(sid)
+            deduped_active.append(sid)
+
+    return {
+        "verifiable": True,
+        "session_registered": True,
+        "stop_confirmed": len(deduped_active) == 0,
+        "active_session_ids": deduped_active,
+    }
+
+
 def record_lifecycle_event(
     event_id: str,
     action: str,
@@ -324,17 +422,18 @@ def record_lifecycle_event(
                 "prior_status": status,
             }
 
-        # Case B: canonical was dispatched but never confirmed. Check
-        # whether the live session wrote a diary after dispatch; if so
-        # the intent has already been satisfied by the model and we
-        # must NOT ask Desktop to re-run the plan.
+        # Case B: canonical was dispatched but never confirmed. Only
+        # short-circuit if the session already wrote the diary AND no
+        # linked NEXO session remains active.
         if prior_plan_id and prior_dispatched_at and not prior_done_at:
+            stop_state = _session_stop_state(conn, str(session_id)) if session_id else None
+            stop_confirmed = bool(stop_state and stop_state.get("verifiable") and stop_state.get("stop_confirmed"))
             if session_id and _session_diary_since(
                 conn,
                 str(session_id),
                 str(prior_dispatched_at),
                 str(prior_actions_json or ""),
-            ):
+            ) and stop_confirmed:
                 conn.execute(
                     "UPDATE lifecycle_events "
                     "SET delivery_status = 'already_processed', "
@@ -349,7 +448,7 @@ def record_lifecycle_event(
                     "event_id": event_id,
                     "duplicate": True,
                     "prior_status": status,
-                    "reason": "session_diary-already-written",
+                    "reason": "session_diary-and-stop-already-written",
                 }
             # Re-hand the exact same plan so Desktop can resume / finish
             # any actions it didn't complete before the crash.
@@ -538,11 +637,18 @@ def record_complete_canonical(
         for r in results_list
     )
     diary_evidence = _session_diary_evidence(conn, session_id, dispatched_at, actions_json)
+    stop_state = _session_stop_state(conn, session_id) if session_id else {
+        "verifiable": False,
+        "session_registered": False,
+        "stop_confirmed": True,
+        "active_session_ids": [],
+    }
     diary_required = action in _DIARY_TRIGGERING and bool(session_id)
     session_registered = _session_is_linked_to_nexo(conn, session_id) if diary_required else bool(session_id)
     session_unregistered = diary_required and not session_registered
     diary_missing = diary_required and diary_evidence is None
-    effective = "retryable_error" if (any_failure or diary_missing) else "canonical_done"
+    stop_missing = diary_required and bool(stop_state.get("verifiable")) and not bool(stop_state.get("stop_confirmed"))
+    effective = "retryable_error" if (any_failure or diary_missing or stop_missing) else "canonical_done"
     last_error = None
     if session_unregistered:
         last_error = SESSION_NOT_LINKED_REASON
@@ -550,6 +656,8 @@ def record_complete_canonical(
         last_error = "one-or-more-actions-failed"
     elif diary_missing:
         last_error = "canonical-diary-not-confirmed"
+    elif stop_missing:
+        last_error = "canonical-stop-not-confirmed"
     conn.execute(
         "UPDATE lifecycle_events "
         "SET delivery_status = ?, "
@@ -573,8 +681,11 @@ def record_complete_canonical(
         "failed_actions": any_failure,
         "diary_confirmed": diary_evidence is not None,
         "diary_required": diary_required,
+        "stop_confirmed": not stop_missing,
+        "stop_required": diary_required,
         "session_registered": session_registered,
         "session_diary_id": diary_evidence.get("session_diary_id") if diary_evidence else None,
+        "active_session_ids": list(stop_state.get("active_session_ids") or []),
         "reason": last_error if effective == "retryable_error" else None,
     }
 
@@ -635,6 +746,74 @@ def wait_for_canonical_diary(
         time.sleep(min(poll_s, max(0.0, deadline - time.monotonic())))
 
 
+def wait_for_canonical_stop(
+    event_id: str,
+    timeout_ms: int = 10_000,
+    poll_ms: int = 500,
+) -> Dict[str, Any]:
+    """Poll until the canonical lifecycle session no longer has active linked SIDs."""
+    if not event_id:
+        return {"status": "rejected", "reason": "missing-event-id"}
+
+    timeout_s = max(0.0, float(timeout_ms or 0) / 1000.0)
+    poll_s = max(0.05, float(poll_ms or 500) / 1000.0)
+    deadline = time.monotonic() + timeout_s
+
+    while True:
+        conn = get_db()
+        row = conn.execute(
+            "SELECT session_id, action FROM lifecycle_events WHERE event_id = ?",
+            (str(event_id),),
+        ).fetchone()
+        if row is None:
+            return {"status": "rejected", "reason": "unknown-event-id", "event_id": event_id}
+
+        session_id = str(row[0] or "")
+        action = str(row[1] or "")
+        stop_required = action in _DIARY_TRIGGERING and bool(session_id)
+        if not stop_required:
+            return {
+                "status": "ok",
+                "event_id": event_id,
+                "stop_required": False,
+                "stop_confirmed": True,
+                "session_registered": bool(session_id),
+                "active_session_ids": [],
+            }
+
+        stop_state = _session_stop_state(conn, session_id)
+        if not stop_state.get("verifiable"):
+            return {
+                "status": "retryable_error",
+                "event_id": event_id,
+                "stop_required": True,
+                "stop_confirmed": False,
+                "session_registered": False,
+                "active_session_ids": [],
+                "reason": SESSION_NOT_LINKED_REASON,
+            }
+        if stop_state.get("stop_confirmed"):
+            return {
+                "status": "ok",
+                "event_id": event_id,
+                "stop_required": True,
+                "stop_confirmed": True,
+                "session_registered": True,
+                "active_session_ids": [],
+            }
+        if time.monotonic() >= deadline:
+            return {
+                "status": "retryable_error",
+                "event_id": event_id,
+                "stop_required": True,
+                "stop_confirmed": False,
+                "session_registered": True,
+                "active_session_ids": list(stop_state.get("active_session_ids") or []),
+                "reason": "canonical-stop-not-confirmed",
+            }
+        time.sleep(min(poll_s, max(0.0, deadline - time.monotonic())))
+
+
 def get_lifecycle_event(event_id: str) -> Optional[Dict[str, Any]]:
     if not event_id:
         return None

package/src/lifecycle_prompts.py

@@ -19,7 +19,7 @@ import json
 from typing import Any, Dict, List, Optional
 
 
-PLAN_VERSION = 3
+PLAN_VERSION = 4
 
 
 # Actions that trigger a canonical diary+stop plan. `switch` and
@@ -37,6 +37,7 @@ DEFAULT_RESUME_TIMEOUT_MS = 2_000
 DEFAULT_INJECT_TIMEOUT_MS = 30_000
 DEFAULT_DIARY_WAIT_TIMEOUT_MS = 45_000
 DEFAULT_STOP_TIMEOUT_MS = 3_000
+DEFAULT_STOP_WAIT_TIMEOUT_MS = 10_000
 
 
 def canonical_plan_id(event_id: str, plan_version: int = PLAN_VERSION) -> str:
@@ -150,6 +151,15 @@ def build_canonical_plan(
             evidence="session_diary",
         ),
         _canonical_action("a4", "stop_session", str(session_id), DEFAULT_STOP_TIMEOUT_MS),
+        _canonical_action(
+            "a5",
+            "wait_for_stop",
+            str(session_id),
+            DEFAULT_STOP_WAIT_TIMEOUT_MS,
+            event_id=str(event_id),
+            expected_tool_call="nexo_stop",
+            evidence="session_stop",
+        ),
     ]
     return {
         "canonical_plan_id": canonical_plan_id(event_id, PLAN_VERSION),

package/src/plugins/lifecycle_events.py

@@ -168,6 +168,48 @@ def handle_nexo_lifecycle_wait_for_diary(
     return json.dumps(ack, ensure_ascii=False)
 
 
+def handle_nexo_lifecycle_wait_for_stop(
+    event_id: str,
+    timeout_ms: int = 10_000,
+    poll_ms: int = 500,
+) -> str:
+    """Wait until a canonical lifecycle event no longer has an active NEXO session."""
+    try:
+        ack = lifecycle_events.wait_for_canonical_stop(
+            event_id=str(event_id or ""),
+            timeout_ms=int(timeout_ms or 0),
+            poll_ms=int(poll_ms or 500),
+        )
+    except Exception as exc:
+        return json.dumps({
+            "status": "retryable_error",
+            "reason": f"{type(exc).__name__}: {exc}",
+            "handler_threw": True,
+        }, ensure_ascii=False)
+    return json.dumps(ack, ensure_ascii=False)
+
+
+def handle_nexo_lifecycle_stop_nexo_session(
+    sid: str,
+) -> str:
+    """Best-effort explicit stop of a NEXO SID for Desktop lifecycle cleanup."""
+    try:
+        from tools_sessions import handle_stop
+
+        message = handle_stop(str(sid or ""))
+        return json.dumps({
+            "status": "ok",
+            "sid": str(sid or ""),
+            "message": message,
+        }, ensure_ascii=False)
+    except Exception as exc:
+        return json.dumps({
+            "status": "retryable_error",
+            "sid": str(sid or ""),
+            "reason": f"{type(exc).__name__}: {exc}",
+        }, ensure_ascii=False)
+
+
 TOOLS = [
     (
         handle_nexo_lifecycle_event,
@@ -189,4 +231,14 @@ TOOLS = [
         "nexo_lifecycle_wait_for_diary",
         "Wait for concrete session_diary evidence for a canonical lifecycle event before Desktop stops the session.",
     ),
+    (
+        handle_nexo_lifecycle_wait_for_stop,
+        "nexo_lifecycle_wait_for_stop",
+        "Wait until the linked NEXO session is no longer active for a canonical lifecycle event.",
+    ),
+    (
+        handle_nexo_lifecycle_stop_nexo_session,
+        "nexo_lifecycle_stop_nexo_session",
+        "Best-effort explicit nexo_stop by SID for Desktop lifecycle cleanup.",
+    ),
 ]