nexo-brain 7.23.4 → 7.23.6

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.23.4",
+  "version": "7.23.6",
   "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.23.4` is the current packaged-runtime line. Patch over v7.23.3 - release tags now fail closed when npm publication fails and OpenClaw lockfile metadata stays synchronized with the release version.
+Version `7.23.6` is the current packaged-runtime line. Patch over v7.23.5 - `nexo update` clears safe legacy `cognitive.db` shadows and keeps superseded archives under runtime backup retention.
+
+Previously in `7.23.5`: patch over v7.23.4 - `nexo update` keeps external CLI maintenance summary copy in English.
 
 Previously in `7.23.3`: patch over v7.23.2 - Followup runner skips DONE terminal statuses so already-finished followups do not re-enter executable batches.
 

package/package.json

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

@@ -32,6 +32,7 @@ except ModuleNotFoundError as exc:
             sys.path.insert(0, core_path)
     from product_mode import enforce_desktop_product_contract
 from runtime_home import export_resolved_nexo_home, managed_nexo_home
+from cognitive_paths import cleanup_legacy_cognitive_db_artifacts
 
 try:
     from tree_hygiene import is_duplicate_artifact_name
@@ -3505,7 +3506,7 @@ def _format_external_clis_results(results: dict) -> list[str]:
             any_updated = True
             lines.append(
                 f"  CLI updated: {pkg} {entry.get('old')} -> {entry.get('new')} "
-                f"— reinicia terminal para activar"
+                f"— restart the terminal to activate"
             )
         elif status == "already_latest":
             any_checked_latest = True
@@ -3518,7 +3519,7 @@ def _format_external_clis_results(results: dict) -> list[str]:
         # CLIs that the operator never installed shouldn't spam the summary.
 
     if not any_updated and not any_failed and any_checked_latest:
-        lines.append("  CLIs externos: ya en última versión")
+        lines.append("  External CLIs: already on latest versions")
 
     return lines
 
@@ -4747,6 +4748,17 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     except Exception as exc:
         actions.append(f"legacy-personal-brain-db-stubs-warning:{exc.__class__.__name__}")
 
+    try:
+        cognitive_cleanup = cleanup_legacy_cognitive_db_artifacts(dry_run=False)
+        removed = len(cognitive_cleanup.get("removed", []) or [])
+        archived = len(cognitive_cleanup.get("archived", []) or [])
+        if removed:
+            actions.append(f"legacy-cognitive-db-duplicates-removed:{removed}")
+        if archived:
+            actions.append(f"legacy-cognitive-db-archived:{archived}")
+    except Exception as exc:
+        actions.append(f"legacy-cognitive-db-warning:{exc.__class__.__name__}")
+
     try:
         _emit_progress(progress_fn, "Applying Desktop product contract...")
         contract = enforce_desktop_product_contract(source="runtime_post_sync")

package/src/cognitive_paths.py

@@ -7,6 +7,7 @@ import json
 import os
 import shutil
 import sqlite3
+import tarfile
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -68,10 +69,12 @@ def _sha256(path: Path) -> str:
 def _sqlite_signature(path: Path) -> dict[str, Any]:
     if not path.exists():
         return {"exists": False}
+    stat = path.stat()
     signature: dict[str, Any] = {
         "exists": True,
         "path": str(path),
-        "size_bytes": path.stat().st_size,
+        "size_bytes": stat.st_size,
+        "mtime_epoch": stat.st_mtime,
         "sha256": _sha256(path),
     }
     try:
@@ -101,6 +104,10 @@ def _migration_marker_path() -> Path:
     return paths.runtime_state_dir() / "cognitive-db-migration.json"
 
 
+def _cleanup_marker_path() -> Path:
+    return paths.runtime_state_dir() / "cognitive-db-cleanup.jsonl"
+
+
 def _write_migration_marker(source: Path, target: Path) -> None:
     marker = {
         "at": datetime.now(timezone.utc).isoformat(),
@@ -115,6 +122,190 @@ def _write_migration_marker(source: Path, target: Path) -> None:
     marker_path.write_text(json.dumps(marker, indent=2, sort_keys=True) + "\n", encoding="utf-8")
 
 
+def _append_cleanup_marker(event: dict[str, Any]) -> None:
+    marker_path = _cleanup_marker_path()
+    marker_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "at": datetime.now(timezone.utc).isoformat(),
+        **event,
+    }
+    with marker_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, sort_keys=True) + "\n")
+
+
+def _sidecar_paths(db_path: Path) -> list[Path]:
+    return [db_path, Path(f"{db_path}-wal"), Path(f"{db_path}-shm")]
+
+
+def _existing_sidecars(db_path: Path) -> list[Path]:
+    return [path for path in _sidecar_paths(db_path) if path.exists()]
+
+
+def _wal_has_uncheckpointed_data(db_path: Path) -> bool:
+    wal_path = Path(f"{db_path}-wal")
+    try:
+        return wal_path.is_file() and wal_path.stat().st_size > 0
+    except OSError:
+        return True
+
+
+def _canonical_supersedes_legacy(canonical_sig: dict[str, Any], legacy_sig: dict[str, Any]) -> bool:
+    if not canonical_sig.get("exists") or not legacy_sig.get("exists"):
+        return False
+    if not canonical_sig.get("sqlite_ok") or not legacy_sig.get("sqlite_ok"):
+        return False
+    if float(canonical_sig.get("mtime_epoch") or 0) < float(legacy_sig.get("mtime_epoch") or 0):
+        return False
+    canonical_tables = set(canonical_sig.get("tables") or [])
+    legacy_tables = set(legacy_sig.get("tables") or [])
+    if canonical_tables and legacy_tables and not legacy_tables.issubset(canonical_tables):
+        return False
+    return True
+
+
+def _remove_paths(paths_to_remove: list[Path]) -> list[str]:
+    removed: list[str] = []
+    for path in paths_to_remove:
+        try:
+            if path.exists():
+                path.unlink()
+                removed.append(str(path))
+        except FileNotFoundError:
+            continue
+    return removed
+
+
+def _archive_and_remove_legacy_db(
+    legacy_db: Path,
+    *,
+    canonical_sig: dict[str, Any],
+    legacy_sig: dict[str, Any],
+    reason: str,
+) -> dict[str, Any]:
+    files = _existing_sidecars(legacy_db)
+    backup_root = paths.create_backup_dir("legacy-cognitive-db")
+    backup_dir = Path(backup_root)
+    archive_path = backup_dir / "cognitive-legacy.tar.gz"
+    manifest_path = backup_dir / "manifest.json"
+    with tarfile.open(archive_path, "w:gz") as archive:
+        for file_path in files:
+            archive.add(file_path, arcname=file_path.name)
+    with tarfile.open(archive_path, "r:gz") as archive:
+        archived_names = sorted(archive.getnames())
+    archive_sha = _sha256(archive_path)
+    manifest = {
+        "reason": reason,
+        "source": str(legacy_db),
+        "archived_files": [str(path) for path in files],
+        "archive": str(archive_path),
+        "archive_sha256": archive_sha,
+        "archive_members": archived_names,
+        "canonical": canonical_sig,
+        "legacy": legacy_sig,
+    }
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    removed = _remove_paths(files)
+    paths.finalize_backup_snapshot(backup_dir)
+    _append_cleanup_marker({
+        "action": "archive_superseded_legacy",
+        "source": str(legacy_db),
+        "archive": str(archive_path),
+        "archive_sha256": archive_sha,
+        "removed": removed,
+        "reason": reason,
+    })
+    return {
+        "path": str(legacy_db),
+        "action": "archived",
+        "archive_path": str(archive_path),
+        "manifest_path": str(manifest_path),
+        "removed": removed,
+        "reason": reason,
+    }
+
+
+def cleanup_legacy_cognitive_db_artifacts(*, dry_run: bool = False) -> dict[str, Any]:
+    """Remove or archive safe legacy cognitive DB shadows.
+
+    Identical legacy duplicates are deleted directly. Divergent legacy DBs are
+    only archived when the canonical DB is valid, newer, and has a compatible
+    schema. Ambiguous cases are left in place so write callers still block.
+    """
+    override = _configured_override()
+    report: dict[str, Any] = {
+        "ok": True,
+        "dry_run": dry_run,
+        "removed": [],
+        "archived": [],
+        "skipped": [],
+        "errors": [],
+    }
+    if override is not None:
+        report["skipped"].append({"reason": "env_override", "path": str(override)})
+        return report
+
+    canonical = canonical_cognitive_db_path()
+    canonical_sig = _sqlite_signature(canonical)
+    if not canonical_sig.get("exists"):
+        report["skipped"].append({"reason": "canonical_missing", "path": str(canonical)})
+        return report
+    if not canonical_sig.get("sqlite_ok"):
+        report["ok"] = False
+        report["skipped"].append({"reason": "canonical_not_sqlite_ok", "path": str(canonical)})
+        return report
+
+    for legacy_db in legacy_cognitive_db_paths():
+        legacy_sig = _sqlite_signature(legacy_db)
+        if not legacy_sig.get("exists"):
+            continue
+        files = _existing_sidecars(legacy_db)
+        if _wal_has_uncheckpointed_data(legacy_db):
+            report["skipped"].append({"path": str(legacy_db), "reason": "legacy_wal_has_data"})
+            continue
+        if legacy_sig.get("sha256") == canonical_sig.get("sha256"):
+            item = {
+                "path": str(legacy_db),
+                "action": "removed-identical-duplicate",
+                "files": [str(path) for path in files],
+            }
+            if not dry_run:
+                item["removed"] = _remove_paths(files)
+                _append_cleanup_marker({
+                    "action": "remove_identical_duplicate",
+                    "source": str(legacy_db),
+                    "removed": item["removed"],
+                    "legacy_sha256": legacy_sig.get("sha256"),
+                })
+            report["removed"].append(item)
+            continue
+        if _canonical_supersedes_legacy(canonical_sig, legacy_sig):
+            if dry_run:
+                report["archived"].append({
+                    "path": str(legacy_db),
+                    "action": "would-archive-superseded-legacy",
+                    "reason": "canonical_newer_schema_compatible",
+                })
+                continue
+            try:
+                report["archived"].append(_archive_and_remove_legacy_db(
+                    legacy_db,
+                    canonical_sig=canonical_sig,
+                    legacy_sig=legacy_sig,
+                    reason="canonical_newer_schema_compatible",
+                ))
+            except Exception as exc:
+                report["ok"] = False
+                report["errors"].append({"path": str(legacy_db), "error": str(exc)})
+            continue
+        report["skipped"].append({
+            "path": str(legacy_db),
+            "reason": "divergent_requires_manual_review",
+            "canonical_mtime_epoch": canonical_sig.get("mtime_epoch"),
+            "legacy_mtime_epoch": legacy_sig.get("mtime_epoch"),
+        })
+    return report
+
+
 def audit_cognitive_db_paths() -> dict[str, Any]:
     canonical = canonical_cognitive_db_path()
     canonical_sig = _sqlite_signature(canonical)
@@ -173,7 +364,14 @@ def migrate_legacy_cognitive_db_if_needed() -> dict[str, Any]:
     canonical.parent.mkdir(parents=True, exist_ok=True)
     shutil.copy2(source, canonical)
     _write_migration_marker(source, canonical)
-    return {"migrated": True, "reason": "legacy_copied", "source": str(source), "path": str(canonical)}
+    cleanup = cleanup_legacy_cognitive_db_artifacts()
+    return {
+        "migrated": True,
+        "reason": "legacy_copied",
+        "source": str(source),
+        "path": str(canonical),
+        "cleanup": cleanup,
+    }
 
 
 def resolve_cognitive_db(*, for_write: bool = True, migrate: bool = True, create_parent: bool = True) -> Path:
@@ -183,6 +381,7 @@ def resolve_cognitive_db(*, for_write: bool = True, migrate: bool = True, create
         target.parent.mkdir(parents=True, exist_ok=True)
     if migrate:
         migrate_legacy_cognitive_db_if_needed()
+        cleanup_legacy_cognitive_db_artifacts()
     audit = audit_cognitive_db_paths()
     if for_write and audit["status"] == "error":
         raise CognitiveDbPathConflict(
@@ -191,4 +390,3 @@ def resolve_cognitive_db(*, for_write: bool = True, migrate: bool = True, create
             + ", ".join(entry["path"] for entry in audit["legacy"] if entry["signature"].get("exists"))
         )
     return target
-

package/src/scripts/prune_runtime_backups.py

@@ -92,6 +92,7 @@ TECHNICAL_PREFIXES = (
     "desktop-local-install-",
     "packaged-code-f06-conflicts-",
     "legacy-shim-conflicts-",
+    "legacy-cognitive-db-",
     "legacy-personal-brain-db-stubs-",
     "legacy-root-db-stubs-",
     "codex-live-sync-",