nexo-brain 7.30.2 → 7.30.4

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.2",
+  "version": "7.30.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,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.30.2` is the current packaged-runtime line. Patch release over v7.30.1 - Deep Sleep now fails closed on partial nightly runs, carries complete learning context into synthesis, writes an explicit agent start packet, and creates governed followups with verification, priority, owner, and date fields.
+Version `7.30.4` is the current packaged-runtime line. Patch release over v7.30.3 - local runtime update post-sync now gives bounded Memory Fabric repair enough time to finish, and headless automations now treat `nexo_stop` as a terminal close so followup/deep-sleep runners do not reopen no-op protocol loops.
+
+Previously in `7.30.3`: patch release over v7.30.2 - release closeout now protects the freshly written runtime backup from technical pruning and validates protocol evidence against the canonical `runtime/data/nexo.db` layout.
+
+Previously in `7.30.2`: patch release over v7.30.1 - Deep Sleep now fails closed on partial nightly runs, carries complete learning context into synthesis, writes an explicit agent start packet, and creates governed followups with verification, priority, owner, and date fields.
 
 Previously in `7.30.1`: patch release over v7.30.0 - morning briefings now behave more like a start-of-day assistant, explain news/weather as verified optional sources, and keep user type inference inside NEXO instead of asking the user to choose a role manually.
 

package/package.json

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

@@ -98,6 +98,7 @@ TEMPLATE_FILE = _RESOLVED_REPO_DIR / "templates" / "CLAUDE.md.template"
 
 CHECK_COOLDOWN_SECONDS = 3600  # 1 hour
 GIT_TIMEOUT_SECONDS = 4  # stay well under the 5s total budget
+RUNTIME_POST_SYNC_TIMEOUT_SECONDS = 180
 CRITICAL_BACKUP_TABLES = ("learnings", "session_diary", "guard_checks", "protocol_debt")
 LOCAL_CONTEXT_BACKUP_TABLES = (
     "local_index_roots",
@@ -4883,7 +4884,7 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
             cwd=str(dest),
             capture_output=True,
             text=True,
-            timeout=60,
+            timeout=RUNTIME_POST_SYNC_TIMEOUT_SECONDS,
             env=env,
         )
         if init_result.returncode != 0:

package/src/enforcement_engine.py

@@ -475,6 +475,10 @@ class HeadlessEnforcer:
         # per task cycle. Cleared on skill_match OR task_close.
         self._multi_step_event_fired: bool = False
         self._post_close_cooldown_until: float = 0.0
+        # A headless nexo_stop is terminal for the automation cycle. Once
+        # seen, periodic/conditional reminders stay suppressed so cron
+        # runners can reach TURN_END instead of reopening the task loop.
+        self._session_stopped: bool = False
         try:
             self._post_close_cooldown_seconds = max(
                 0,
@@ -2287,6 +2291,10 @@ class HeadlessEnforcer:
             self._start_post_close_cooldown()
             self._resolve_r17_commitments_from_task_close(tool_input)
 
+        if name == "nexo_stop":
+            self._session_stopped = True
+            self._start_post_close_cooldown()
+
         # v7.7 Gap 1 — autonomous detector for multi_step_task_detected.
         # The event was dispatched by the map but nothing ever raised it.
         # Heuristic: three or more edit/execute/delegate calls within the
@@ -2602,6 +2610,9 @@ class HeadlessEnforcer:
             _logger.info("POST_CLOSE_COOLDOWN: cleared %d queued protocol injection(s)", removed)
 
     def check_periodic(self):
+        if getattr(self, "_session_stopped", False):
+            _logger.info("SESSION_STOPPED: periodic checks suppressed (nexo_stop seen)")
+            return
         if self._post_close_cooldown_active():
             _logger.info("POST_CLOSE_COOLDOWN: periodic checks suppressed")
             return

package/src/paths.py

@@ -60,6 +60,7 @@ import shutil
 import subprocess
 import sys
 import time
+from collections.abc import Iterable
 from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
@@ -465,6 +466,7 @@ def run_runtime_backup_prune(
     max_bytes: str | int | None = None,
     backups_root: Path | None = None,
     delete_all_technical: bool = False,
+    protect_paths: Iterable[str | Path] | None = None,
     timeout: int = 120,
 ) -> dict:
     """Run the technical-backup pruner. Safe no-op when the script is absent."""
@@ -487,6 +489,8 @@ def run_runtime_backup_prune(
     ]
     if delete_all_technical:
         args.append("--delete-all-technical")
+    for protected in protect_paths or ():
+        args.extend(["--protect", str(protected)])
     try:
         proc = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
         report = json.loads(proc.stdout or "{}") if proc.stdout.strip().startswith("{") else {}
@@ -634,10 +638,13 @@ def create_backup_path(prefix: str, suffix: str = "", *, backups_root: Path | No
 def finalize_backup_snapshot(_path: Path | str | None = None, *, backups_root: Path | None = None) -> dict:
     """Post-snapshot cleanup; callers invoke after writing large artifacts."""
     root = Path(backups_root) if backups_root is not None else None
+    protect_paths = []
     if root is None and _path is not None:
         snapshot = Path(_path)
         root = snapshot.parent
-    return run_runtime_backup_prune(backups_root=root)
+    if _path is not None:
+        protect_paths.append(Path(_path))
+    return run_runtime_backup_prune(backups_root=root, protect_paths=protect_paths)
 
 
 def memory_dir() -> Path:

package/src/scripts/prune_runtime_backups.py

@@ -261,6 +261,14 @@ def gather_entries(backups_root: Path) -> list[dict]:
     return items
 
 
+def path_key(path: str | Path) -> str:
+    candidate = Path(path)
+    try:
+        return str(candidate.resolve())
+    except OSError:
+        return str(candidate.absolute())
+
+
 def plan_prunes(
     items: list[dict],
     *,
@@ -420,11 +428,24 @@ def run(args: argparse.Namespace) -> int:
         local_context_keep=max(0, args.local_context_keep),
         hourly_keep=max(0, args.hourly_keep),
     )
+    protected_paths = {path_key(path) for path in (args.protect or [])}
+    protected_ids: set[int] = set()
+    if protected_paths:
+        protected_items = [item for item in items if path_key(item["path"]) in protected_paths]
+        protected_ids = {id(item) for item in protected_items}
+        if protected_ids:
+            to_delete = [item for item in to_delete if id(item) not in protected_ids]
+            keep_ids = {id(item) for item in to_keep}
+            to_keep.extend(item for item in protected_items if id(item) not in keep_ids)
 
     if args.delete_all_technical:
         delete_ids = {id(item) for item in to_delete}
         for item in items:
-            if item["class"] in {"TECHNICAL", "TEMPORARY"} and id(item) not in delete_ids:
+            if (
+                item["class"] in {"TECHNICAL", "TEMPORARY"}
+                and id(item) not in delete_ids
+                and id(item) not in protected_ids
+            ):
                 to_delete.append(item)
                 delete_ids.add(id(item))
         to_keep = [item for item in items if id(item) not in delete_ids]
@@ -447,6 +468,7 @@ def run(args: argparse.Namespace) -> int:
             "tmp_ttl_minutes": args.tmp_ttl_minutes,
             "local_context_keep": args.local_context_keep,
             "hourly_keep": args.hourly_keep,
+            "protected_paths": sorted(protected_paths),
             "restore_point_guard": restore_guard,
         },
         "totals": {
@@ -560,6 +582,7 @@ def main() -> int:
     ap.add_argument("--tmp-ttl-minutes", type=int, default=int(os.environ.get("NEXO_BACKUP_TMP_TTL_MINUTES", "30")), help="delete orphan temporary backup files older than this (default: 30)")
     ap.add_argument("--local-context-keep", type=int, default=int(os.environ.get("NEXO_LOCAL_CONTEXT_BACKUP_KEEP_LAST", "1")), help="local-context backup files to keep under the global cap (default: 1)")
     ap.add_argument("--hourly-keep", type=int, default=int(os.environ.get("NEXO_BACKUP_KEEP_LAST", "3")), help="hourly nexo DB backups to keep under the global cap (default: 3)")
+    ap.add_argument("--protect", action="append", default=[], help="backup path to keep even if it is otherwise prunable; repeat for multiple paths")
     args = ap.parse_args()
     try:
         return run(args)