nexo-brain 7.30.26 → 7.30.28

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.26",
+  "version": "7.30.28",
   "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.26` is the current packaged-runtime line. Patch release over v7.30.25 - `nexo update` now copies packaged core scripts through the F0.6 `scripts -> core/scripts` shim, so watchdog fixes reach the active LaunchAgent path.
+Version `7.30.28` is the current packaged-runtime line. Patch release over v7.30.27 - F0.6 runtime repairs now run through an existing post-install hook, so older updaters execute script-conflict recovery and `core/current` refresh on the first upgrade.
+
+Previously in `7.30.27`: patch release over v7.30.26 - post-update repair now recovers core scripts archived by older F0.6 shim reconciliation and refreshes `core/current` from `core`, so same-version snapshots cannot keep stale watchdog code.
+
+Previously in `7.30.26`: patch release over v7.30.25 - `nexo update` now copies packaged core scripts through the F0.6 `scripts -> core/scripts` shim, so watchdog fixes reach the active LaunchAgent path.
 
 Previously in `7.30.25`: patch release over v7.30.24 - Desktop-facing maintenance diagnostics now self-heal or stay informational when the runtime is healthy, and watchdog uses the canonical cognitive DB layout.
 

package/package.json

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

@@ -5444,10 +5444,20 @@ def _persist_guardian_hard_defaults(dest: Path) -> tuple[bool, str | None]:
           non-default value (``shadow`` / ``off`` / anything else). Only
           fills missing keys or upgrades explicit defaults.
     """
+    def _join_messages(*messages: str | None) -> str | None:
+        parts = [str(message) for message in messages if str(message or "").strip()]
+        return ";".join(parts) if parts else None
+
+    repair_message = None
+    try:
+        _repair_changed, repair_message = _run_f06_post_update_repairs(dest)
+    except Exception as exc:
+        repair_message = f"f06-post-update-repair-warning:{exc.__class__.__name__}"
+
     if _is_ephemeral_runtime_install(dest):
-        return False, "guardian-hard-persist-skipped:ephemeral"
+        return False, _join_messages("guardian-hard-persist-skipped:ephemeral", repair_message)
     if os.environ.get("NEXO_GUARDIAN_PERSIST_HARD", "").strip().lower() == "off":
-        return False, "guardian-hard-persist-skipped:operator-opt-out"
+        return False, _join_messages("guardian-hard-persist-skipped:operator-opt-out", repair_message)
 
     config_path = dest / "personal" / "config" / "guardian-runtime-overrides.json"
     config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -5477,16 +5487,16 @@ def _persist_guardian_hard_defaults(dest: Path) -> tuple[bool, str | None]:
             current[key] = default
 
     if current == original and config_path.is_file():
-        return False, None
+        return False, repair_message
 
     try:
         tmp_path = config_path.with_suffix(config_path.suffix + ".tmp")
         tmp_path.write_text(json.dumps(current, indent=2, ensure_ascii=False) + "\n")
         tmp_path.replace(config_path)
     except Exception as exc:  # pragma: no cover - filesystem failures
-        return False, f"guardian-hard-persist-error:{exc.__class__.__name__}"
+        return False, _join_messages(f"guardian-hard-persist-error:{exc.__class__.__name__}", repair_message)
 
-    return True, None
+    return True, repair_message
 
 
 from datetime import datetime as _adaptive_datetime  # isolated alias; other modules use ``time.time()``
@@ -5590,12 +5600,141 @@ def _maybe_promote_adaptive_weights_empirically(dest: Path) -> tuple[bool, str |
     return True, None
 
 
+def _promote_f06_core_scripts_from_latest_legacy_conflict(dest: Path) -> tuple[bool, str | None]:
+    """Recover core script updates archived by the pre-fix F0.6 shim path.
+
+    Older updaters copied packaged scripts into ``NEXO_HOME/scripts`` after
+    breaking the F0.6 compatibility symlink. The subsequent shim reconciliation
+    saw those fresh scripts as legacy conflicts and archived them under
+    ``runtime/backups/legacy-shim-conflicts-*`` instead of replacing
+    ``core/scripts``. This hook runs from the freshly-copied release tree, so it
+    can repair the first upgrade that introduces the updater fix.
+    """
+    try:
+        marker = (dest / ".structure-version").read_text(encoding="utf-8").strip()
+    except Exception:
+        marker = ""
+    if marker != "F0.6":
+        return False, None
+
+    core_scripts = dest / "core" / "scripts"
+    backups_dir = dest / "runtime" / "backups"
+    if not core_scripts.is_dir() or not backups_dir.is_dir():
+        return False, None
+
+    try:
+        candidates = sorted(
+            [p for p in backups_dir.glob("legacy-shim-conflicts-*") if (p / "scripts").is_dir()],
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+    except Exception:
+        return False, "f06-core-scripts-promote-warning:scan"
+
+    if not candidates:
+        return False, None
+
+    def _should_skip(path: Path) -> bool:
+        return (
+            path.name == "__pycache__"
+            or path.name.startswith(".")
+            or is_duplicate_artifact_name(path)
+        )
+
+    def _source_is_not_older(src: Path, dst: Path) -> bool:
+        if not dst.exists() and not dst.is_symlink():
+            return True
+        try:
+            return src.stat().st_mtime >= dst.stat().st_mtime
+        except Exception:
+            return False
+
+    copied = 0
+
+    def _copy_entry(src: Path, dst: Path) -> None:
+        nonlocal copied
+        if _should_skip(src):
+            return
+        if src.is_dir():
+            dst.mkdir(parents=True, exist_ok=True)
+            for child in src.iterdir():
+                _copy_entry(child, dst / child.name)
+            return
+        if not src.is_file() or not _source_is_not_older(src, dst):
+            return
+        try:
+            if dst.exists() and dst.is_file() and src.read_bytes() == dst.read_bytes():
+                return
+        except Exception:
+            pass
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(str(src), str(dst))
+        if src.suffix == ".sh":
+            dst.chmod(0o755)
+        copied += 1
+
+    for backup_root in candidates[:3]:
+        scripts_backup = backup_root / "scripts"
+        try:
+            for item in scripts_backup.iterdir():
+                _copy_entry(item, core_scripts / item.name)
+        except Exception as exc:
+            return False, f"f06-core-scripts-promote-warning:{exc.__class__.__name__}"
+        if copied:
+            return True, f"f06-core-scripts-promoted:{copied}"
+
+    return False, None
+
+
+def _refresh_active_versioned_runtime_snapshot(dest: Path) -> tuple[bool, str | None]:
+    """Rebuild ``core/current`` from ``core`` after an update.
+
+    Version equality is not enough evidence that the active snapshot contains
+    the same bytes as ``core``: a same-version repair can update ``core/scripts``
+    after ``core/current`` was already activated. Refreshing the snapshot keeps
+    Desktop/CLI clients that resolve through ``core/current`` on the repaired
+    runtime tree.
+    """
+    core_root = dest / "core"
+    if not core_root.is_dir() or not (core_root / "cli.py").is_file():
+        return False, None
+    try:
+        from runtime_versioning import activate_versioned_runtime_snapshot, read_version_for_path
+
+        version = str(read_version_for_path(core_root) or "").strip()
+        if not version:
+            return False, "runtime-snapshot-refresh-skipped:missing-version"
+        result = activate_versioned_runtime_snapshot(source_root=core_root, version=version)
+    except Exception as exc:
+        return False, f"runtime-snapshot-refresh-warning:{exc.__class__.__name__}"
+    if not result.get("ok"):
+        return False, f"runtime-snapshot-refresh-warning:{result.get('error', 'unknown')}"
+    return True, f"runtime-snapshot-refreshed:{version}"
+
+
+def _run_f06_post_update_repairs(dest: Path) -> tuple[bool, str | None]:
+    changed = False
+    messages: list[str] = []
+    for repair in (
+        _promote_f06_core_scripts_from_latest_legacy_conflict,
+        _refresh_active_versioned_runtime_snapshot,
+    ):
+        repair_changed, repair_message = repair(dest)
+        changed = changed or repair_changed
+        if repair_message:
+            messages.append(repair_message)
+    return changed, ";".join(messages) if messages else None
+
+
 # Whitelist of post-install hooks to invoke from the fresh tree. Each entry
 # is the function name inside ``auto_update.py`` of the freshly-copied
 # code. The subprocess resolves them on the NEW module and calls
 # ``fn(dest)`` returning ``(bool, str | None)``. New hooks added in
 # future releases only need an entry here — no extra wiring.
 _POST_INSTALL_FRESH_HOOKS = (
+    ("f06-post-update-repairs", "_run_f06_post_update_repairs"),
+    ("f06-core-scripts-promoted", "_promote_f06_core_scripts_from_latest_legacy_conflict"),
+    ("runtime-snapshot-refreshed", "_refresh_active_versioned_runtime_snapshot"),
     ("guardian-hard-persisted", "_persist_guardian_hard_defaults"),
     ("adaptive-weights-promoted", "_maybe_promote_adaptive_weights_empirically"),
 )
@@ -5631,7 +5770,7 @@ def _run_post_install_hooks_fresh(dest: Path, *, env: dict | None = None) -> lis
         "import json, sys\n"
         "from pathlib import Path\n"
         f"sys.path.insert(0, {repr(str(code_root))})\n"
-        "hooks = json.loads(" + repr(hook_specs_json) + ")\n"
+        "fallback_hooks = json.loads(" + repr(hook_specs_json) + ")\n"
         f"dest = Path({repr(dest_str)})\n"
         "results = []\n"
         "try:\n"
@@ -5639,6 +5778,11 @@ def _run_post_install_hooks_fresh(dest: Path, *, env: dict | None = None) -> lis
         "except Exception as exc:\n"
         "    print(json.dumps({'error': 'import_auto_update_failed', 'detail': repr(exc)}))\n"
         "    sys.exit(0)\n"
+        "fresh_hooks = getattr(fresh, '_POST_INSTALL_FRESH_HOOKS', None)\n"
+        "if isinstance(fresh_hooks, (list, tuple)) and fresh_hooks:\n"
+        "    hooks = [(str(tag), str(fn)) for tag, fn in fresh_hooks]\n"
+        "else:\n"
+        "    hooks = fallback_hooks\n"
         "for tag, fn_name in hooks:\n"
         "    fn = getattr(fresh, fn_name, None)\n"
         "    if fn is None:\n"