nexo-brain 5.4.1 → 5.4.4

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "5.4.1",
+  "version": "5.4.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,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 `5.4.1` is the current packaged-runtime line: hook hygiene fix — the PostToolUse `capture-session.sh` hook had been reading a nonexistent env var since 2026-04-12, silently writing `"tool":"unknown"` to the Sensory Register for 48 hours. v5.4.1 parses the tool name from stdin JSON, removes the filter that was hiding `Bash`, and purges pre-fix entries from the buffer on update.
+Version `5.4.4` is the current packaged-runtime line: test isolation for tree_hygiene module + fake venv to prevent CI timeout — completes the publish workflow fix from v5.4.3.
 
 Previously in `5.4.0`: runtime event bus at `~/.nexo/runtime/events.ndjson`, `nexo notify`, `nexo health --json`, `nexo logs --tail --json`, and a safe flat→nested migration for `calibration.json`.
 
@@ -630,20 +630,21 @@ PreCompact hook saves full checkpoint if conversation is compressed
     ↓
 PostCompact hook re-injects Core Memory Block → session continues seamlessly
     ↓
-Stop hook triggers mandatory post-mortem:
-  - Self-critique: 5 questions about what could be better
-  - Session buffer: structured entry for the reflection engine
-  - Followups: anything promised gets scheduled
-  - Proactive seeds: what can the next session do without being asked?
+Stop hook refreshes the diary draft and approves immediately:
+  - Latest changes and decisions stay attached to the active session
+  - Session buffer keeps structured tool activity for downstream processing
+  - Followups and closing synthesis happen inline when the agent detects real closing intent
+  - No mid-conversation blocking from the hook itself
     ↓
-Reflection engine processes buffer (after 3+ sessions)
+Nocturnal post-mortem consolidator processes the buffer mechanically
     ↓
 Nocturnal processes: decay, consolidation, self-audit, dreaming
 ```
 
 ### Reflection Engine
 
-After 3+ sessions accumulate, the stop hook triggers `nexo-reflection.py`:
+NEXO still ships `nexo-reflection.py` as a standalone analyzer for `session_buffer.jsonl`.
+It is not currently auto-triggered by the stop hook:
 - Extracts recurring tasks, error patterns, mood trends
 - Updates `user_model.json` with observed behavior
 - No LLM required — runs as pure Python

package/package.json

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

@@ -2115,6 +2115,7 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
             nexo_home=dest,
             runtime_root=dest,
             preferences=normalized_preferences,
+            auto_install_missing_claude=True,
         )
         if client_sync_result.get("ok"):
             actions.append("client-sync")

package/src/client_sync.py

@@ -24,6 +24,7 @@ try:
     from client_preferences import (
         BACKEND_NONE,
         INTERACTIVE_CLIENT_KEYS,
+        detect_installed_clients,
         normalize_backend_key,
         normalize_client_key,
         normalize_client_preferences,
@@ -68,6 +69,16 @@ except Exception:
         }
         return dict(defaults.get(client, {}))
 
+    def detect_installed_clients(user_home: str | os.PathLike[str] | None = None) -> dict[str, dict]:
+        return {
+            "claude_code": {"installed": False, "path": "", "detected_by": "missing"},
+            "codex": {"installed": False, "path": "", "detected_by": "missing"},
+            "claude_desktop": {"installed": False, "path": "", "detected_by": "missing"},
+        }
+
+
+CLAUDE_CODE_NPM_PACKAGE = "@anthropic-ai/claude-code"
+
 
 
 def _user_home() -> Path:
@@ -133,6 +144,108 @@ def _resolve_python(nexo_home: Path, explicit: str = "") -> str:
     return explicit or sys.executable
 
 
+def _cli_install_env(user_home: Path | None = None) -> dict[str, str]:
+    env = os.environ.copy()
+    if user_home is not None:
+        env["HOME"] = str(user_home)
+    return env
+
+
+def _installed_client_path(client_key: str, *, user_home: Path | None = None) -> str:
+    info = detect_installed_clients(user_home=user_home).get(client_key, {})
+    if info.get("installed"):
+        return str(info.get("path") or "")
+    return ""
+
+
+def ensure_claude_code_installed(*, user_home: str | os.PathLike[str] | None = None) -> dict:
+    home_path = Path(user_home).expanduser() if user_home else _user_home()
+    existing = _installed_client_path("claude_code", user_home=home_path)
+    if existing:
+        return {
+            "ok": True,
+            "client": "claude_code",
+            "installed": True,
+            "changed": False,
+            "action": "already_installed",
+            "path": existing,
+            "attempts": [],
+        }
+
+    attempts: list[str] = []
+    env = _cli_install_env(home_path)
+
+    try:
+        probe = subprocess.run(
+            ["npx", "-y", CLAUDE_CODE_NPM_PACKAGE, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+            env=env,
+        )
+        if probe.returncode != 0:
+            attempts.append((probe.stderr or probe.stdout or "npx probe failed").strip())
+    except Exception as exc:
+        attempts.append(f"npx probe failed: {exc}")
+
+    installed_after_probe = _installed_client_path("claude_code", user_home=home_path)
+    if installed_after_probe:
+        return {
+            "ok": True,
+            "client": "claude_code",
+            "installed": True,
+            "changed": True,
+            "action": "installed_via_npx",
+            "path": installed_after_probe,
+            "attempts": attempts,
+        }
+
+    install_cmd = (
+        ["sudo", "npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE]
+        if sys.platform == "linux"
+        else ["npm", "install", "-g", CLAUDE_CODE_NPM_PACKAGE]
+    )
+    install_error = ""
+    try:
+        install = subprocess.run(
+            install_cmd,
+            capture_output=True,
+            text=True,
+            timeout=180,
+            env=env,
+        )
+        if install.returncode != 0:
+            install_error = (install.stderr or install.stdout or "npm install failed").strip()
+            attempts.append(install_error)
+    except Exception as exc:
+        install_error = f"npm install failed: {exc}"
+        attempts.append(install_error)
+
+    installed_path = _installed_client_path("claude_code", user_home=home_path)
+    if installed_path:
+        return {
+            "ok": True,
+            "client": "claude_code",
+            "installed": True,
+            "changed": True,
+            "action": "installed",
+            "path": installed_path,
+            "attempts": attempts,
+        }
+
+    error = install_error or "Claude Code install did not produce a `claude` binary in PATH"
+    return {
+        "ok": False,
+        "client": "claude_code",
+        "installed": False,
+        "changed": False,
+        "action": "failed",
+        "path": "",
+        "attempts": attempts,
+        "error": error,
+    }
+
+
 def build_server_config(
     *,
     nexo_home: str | os.PathLike[str] | None = None,
@@ -856,6 +969,7 @@ def sync_all_clients(
     user_home: str | os.PathLike[str] | None = None,
     enabled_clients: list[str] | tuple[str, ...] | set[str] | None = None,
     preferences: dict | None = None,
+    auto_install_missing_claude: bool = False,
 ) -> dict:
     if enabled_clients is None:
         if preferences is None:
@@ -877,6 +991,10 @@ def sync_all_clients(
         if not enabled_set:
             enabled_set = {"claude_code"}
 
+    install_results: dict[str, dict] = {}
+    if auto_install_missing_claude and "claude_code" in enabled_set:
+        install_results["claude_code"] = ensure_claude_code_installed(user_home=user_home)
+
     def _safe(label: str, fn) -> dict:
         if label not in enabled_set:
             return {
@@ -902,7 +1020,10 @@ def sync_all_clients(
         "claude_desktop": _safe("claude_desktop", sync_claude_desktop),
         "codex": _safe("codex", sync_codex),
     }
-    ok = all(item.get("ok") or item.get("skipped") for item in results.values())
+    ok = (
+        all(item.get("ok") or item.get("skipped") for item in results.values())
+        and all(item.get("ok") for item in install_results.values())
+    )
     return {
         "ok": ok,
         "nexo_home": str(Path(nexo_home).expanduser() if nexo_home else _default_nexo_home()),
@@ -911,6 +1032,7 @@ def sync_all_clients(
             runtime_root,
         )),
         "enabled_clients": sorted(enabled_set),
+        "install_results": install_results,
         "clients": results,
     }
 

package/src/doctor/providers/runtime.py

@@ -1773,7 +1773,7 @@ def check_personal_script_registry(fix: bool = False) -> DoctorCheck:
     )
 
 
-def check_client_backend_preferences() -> DoctorCheck:
+def check_client_backend_preferences(fix: bool = False) -> DoctorCheck:
     schedule = {}
     try:
         if SCHEDULE_FILE.is_file():
@@ -1828,7 +1828,28 @@ def check_client_backend_preferences() -> DoctorCheck:
             repair_plan.append(f"Install {automation_backend} or disable automation in schedule.json")
 
     if not repair_plan and status != "healthy":
-        repair_plan.append("Run `nexo update` or `nexo clients sync` after installing the selected client/backend")
+        repair_plan.append(
+            "Run `nexo doctor --tier runtime --fix` or `nexo update` so the selected client/backend is installed and re-synced where possible"
+        )
+
+    if fix and status != "healthy":
+        try:
+            from client_sync import sync_all_clients
+
+            sync_all_clients(
+                nexo_home=NEXO_HOME,
+                runtime_root=NEXO_CODE,
+                user_home=Path.home(),
+                preferences=prefs,
+                auto_install_missing_claude=True,
+            )
+        except Exception:
+            pass
+        post = check_client_backend_preferences(fix=False)
+        if post.status == "healthy":
+            post.fixed = True
+            post.summary += " (fixed)"
+        return post
 
     def _profile_label(client_key: str, profile: dict[str, str]) -> str:
         bits = [client_key]
@@ -3151,7 +3172,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_watchdog_status),
         safe_check(check_stale_sessions),
         safe_check(check_cron_freshness),
-        safe_check(check_client_backend_preferences),
+        safe_check(check_client_backend_preferences, fix=fix),
         safe_check(check_client_bootstrap_parity, fix=fix),
         safe_check(check_codex_session_parity),
         safe_check(check_codex_conditioned_file_discipline),

package/src/plugins/episodic_memory.py

@@ -3,6 +3,7 @@
 import datetime
 import json
 import time
+from pathlib import Path
 from db import (
     log_decision, update_decision_outcome, search_decisions,
     write_session_diary, read_session_diary,
@@ -10,6 +11,23 @@ from db import (
     recall, get_db, set_linked_outcomes_met,
 )
 
+REPO_ROOT = Path(__file__).resolve().parents[2]
+_REPO_ABS_PREFIX = str(REPO_ROOT) + "/"
+_REPO_IGNORED_TOP_LEVEL = {
+    ".git",
+    ".venv",
+    ".pytest_cache",
+    ".ruff_cache",
+    "__pycache__",
+}
+try:
+    _REPO_TOP_LEVEL_ENTRIES = {
+        path.name for path in REPO_ROOT.iterdir()
+        if path.name not in _REPO_IGNORED_TOP_LEVEL
+    }
+except OSError:
+    _REPO_TOP_LEVEL_ENTRIES = set()
+
 
 def _cognitive_ingest_safe(content, source_type, source_id="", source_title="", domain=""):
     """Ingest to cognitive STM. Silently fails if cognitive engine unavailable."""
@@ -20,6 +38,37 @@ def _cognitive_ingest_safe(content, source_type, source_id="", source_title="",
         pass  # Cognitive is optional — never block operational writes
 
 
+def _iter_change_paths(files: str) -> list[str]:
+    parts = []
+    for chunk in str(files or "").replace("\n", ",").split(","):
+        item = chunk.strip()
+        if item:
+            parts.append(item)
+    return parts
+
+
+def _change_requires_git_commit_ref(files: str) -> bool:
+    for item in _iter_change_paths(files):
+        normalized = item.replace("\\", "/").strip()
+        while normalized.startswith("./"):
+            normalized = normalized[2:]
+        if normalized.startswith(_REPO_ABS_PREFIX):
+            return True
+        top_level = normalized.split("/", 1)[0]
+        if top_level in _REPO_TOP_LEVEL_ENTRIES:
+            return True
+    return False
+
+
+def _format_change_count(count: int) -> str:
+    return f"{count} cambio" if count == 1 else f"{count} cambios"
+
+
+def _recent_change_phrase(count: int) -> str:
+    base = _format_change_count(count)
+    return f"{base} reciente" if count == 1 else f"{base} recientes"
+
+
 def handle_decision_log(domain: str, decision: str, alternatives: str = '',
                         based_on: str = '', confidence: str = 'medium',
                         context_ref: str = '', session_id: str = '',
@@ -226,23 +275,35 @@ def handle_session_diary_write(decisions: str, summary: str,
     # Episodic memory audit — warn about gaps
     warnings = []
     conn = __import__('db').get_db()
-    orphan_changes = conn.execute(
-        "SELECT COUNT(*) FROM change_log WHERE (commit_ref IS NULL OR commit_ref = '')"
-    ).fetchone()[0]
-    recent_orphan_changes = conn.execute(
-        """SELECT COUNT(*) FROM change_log
-           WHERE (commit_ref IS NULL OR commit_ref = '')
-             AND created_at >= datetime('now', '-7 days')"""
-    ).fetchone()[0]
-    if orphan_changes > 0:
-        if recent_orphan_changes > 0 and recent_orphan_changes != orphan_changes:
+    orphan_change_rows = conn.execute(
+        """SELECT files, created_at FROM change_log
+           WHERE (commit_ref IS NULL OR commit_ref = '')"""
+    ).fetchall()
+    repo_orphan_changes = 0
+    recent_repo_orphan_changes = 0
+    recent_cutoff = conn.execute("SELECT datetime('now', '-7 days')").fetchone()[0]
+    for row in orphan_change_rows:
+        files = row["files"] if hasattr(row, "keys") else row[0]
+        created_at = row["created_at"] if hasattr(row, "keys") else row[1]
+        if not _change_requires_git_commit_ref(files):
+            continue
+        repo_orphan_changes += 1
+        if created_at >= recent_cutoff:
+            recent_repo_orphan_changes += 1
+    if repo_orphan_changes > 0:
+        if recent_repo_orphan_changes > 0 and recent_repo_orphan_changes != repo_orphan_changes:
             warnings.append(
-                f"{recent_orphan_changes} changes recientes sin commit_ref ({orphan_changes} históricas total)"
+                f"{_recent_change_phrase(recent_repo_orphan_changes)} de repo sin commit_ref "
+                f"({_format_change_count(repo_orphan_changes)} de repo total)"
+            )
+        elif recent_repo_orphan_changes > 0:
+            warnings.append(
+                f"{_recent_change_phrase(recent_repo_orphan_changes)} de repo sin commit_ref"
             )
-        elif recent_orphan_changes > 0:
-            warnings.append(f"{recent_orphan_changes} changes recientes sin commit_ref")
         else:
-            warnings.append(f"{orphan_changes} changes históricas sin commit_ref")
+            warnings.append(
+                f"{_format_change_count(repo_orphan_changes)} históricos de repo sin commit_ref"
+            )
     orphan_decisions = conn.execute(
         "SELECT COUNT(*) FROM decisions WHERE (outcome IS NULL OR outcome = '') AND created_at < datetime('now', '-7 days')"
     ).fetchone()[0]
@@ -342,7 +403,16 @@ def handle_change_log(files: str, what_changed: str, why: str,
         pass
     msg = f"Change #{change_id} recorded: {files[:60]} — {what_changed[:60]}"
     if not commit_ref:
-        msg += f"\n⚠ NO COMMIT. Use nexo_change_commit({change_id}, 'hash') after push, or 'server-direct' if it was a direct server edit."
+        if _change_requires_git_commit_ref(files):
+            msg += (
+                f"\n⚠ NO COMMIT. Use nexo_change_commit({change_id}, 'hash') after push."
+            )
+        else:
+            msg += (
+                f"\n⚠ NO COMMIT GIT. If this was a local/server-side change, link a marker "
+                f"with nexo_change_commit({change_id}, 'server-direct') or "
+                f"'local-uncommitted'."
+            )
     return msg
 
 

package/src/plugins/update.py

@@ -479,6 +479,7 @@ def _sync_packaged_clients() -> tuple[bool, str | None]:
             runtime_root=NEXO_HOME,
             operator_name=os.environ.get("NEXO_NAME", ""),
             preferences=preferences,
+            auto_install_missing_claude=True,
         )
     except Exception as e:
         return False, f"client sync failed: {e}"

package/src/scripts/nexo-postmortem-consolidator.py

@@ -87,6 +87,41 @@ def log(msg: str):
         f.write(line + "\n")
 
 
+def _render_sensory_event_content(event: dict) -> str:
+    source = event.get("source", "")
+    if source == "hook-fallback":
+        task_str = " ".join(event.get("tasks", []))
+        if len(task_str) < 50 or "," in task_str:
+            return ""
+
+    parts = []
+    tool_name = str(event.get("tool") or "").strip()
+    if source == "hook" and tool_name:
+        parts.append(f"Tool activity via hook: {tool_name}")
+
+    for key, label in [("tasks", "Tasks"), ("decisions", "Decisions"),
+                       ("errors_resolved", "Errors"), ("user_patterns", "the user")]:
+        val = event.get(key, [])
+        if val:
+            parts.append(f"{label}: {'; '.join(str(v) for v in val[:3])}")
+
+    critique = event.get("self_critique", "")
+    if critique and "hook-fallback" not in critique:
+        parts.append(f"Self-critique: {critique[:200]}")
+
+    return " | ".join(parts)
+
+
+def _rewrite_session_buffer(lines: list[str]) -> None:
+    payload = "\n".join(lines)
+    if payload:
+        payload += "\n"
+
+    tmp_path = SESSION_BUFFER.with_suffix(SESSION_BUFFER.suffix + ".tmp")
+    tmp_path.write_text(payload)
+    tmp_path.replace(SESSION_BUFFER)
+
+
 # ─── Stage 1: Data Collection (Pure Python) ─────────────────────────────────
 
 def collect_data() -> dict:
@@ -257,28 +292,29 @@ def process_sensory_register():
         log("  No session_buffer.jsonl found, skipping")
         return
 
-    today_events = []
+    pending_events = []
+    retained_lines = []
     try:
         with open(SESSION_BUFFER) as f:
             for line in f:
-                line = line.strip()
+                raw_line = line.rstrip("\n")
+                line = raw_line.strip()
                 if not line:
                     continue
                 try:
                     event = json.loads(line)
-                    if event.get("ts", "").startswith(TODAY_STR):
-                        today_events.append(event)
+                    pending_events.append((event, line))
                 except json.JSONDecodeError:
-                    continue
+                    retained_lines.append(raw_line)
     except Exception as e:
         log(f"  Error reading session_buffer: {e}")
         return
 
-    if not today_events:
-        log("  No events from today")
+    if not pending_events:
+        log("  No pending events")
         return
 
-    log(f"  Found {len(today_events)} events")
+    log(f"  Found {len(pending_events)} pending events")
 
     try:
         import cognitive
@@ -287,30 +323,16 @@ def process_sensory_register():
         return
 
     ingested = 0
-    for event in today_events:
-        source = event.get("source", "")
-        if source == "hook-fallback":
-            task_str = " ".join(event.get("tasks", []))
-            if len(task_str) < 50 or "," in task_str:
-                continue
-
-        parts = []
-        for key, label in [("tasks", "Tasks"), ("decisions", "Decisions"),
-                           ("errors_resolved", "Errors"), ("user_patterns", "the user")]:
-            val = event.get(key, [])
-            if val:
-                parts.append(f"{label}: {'; '.join(str(v) for v in val[:3])}")
-
-        critique = event.get("self_critique", "")
-        if critique and "hook-fallback" not in critique:
-            parts.append(f"Self-critique: {critique[:200]}")
-
-        content = " | ".join(parts)
+    processed_events = 0
+    kept_events = 0
+    for event, raw_line in pending_events:
+        content = _render_sensory_event_content(event)
         if not content or len(content) < 20:
+            retained_lines.append(raw_line)
+            kept_events += 1
             continue
 
         try:
-            vec = cognitive.embed(content)
             domain = ""
             lower = content.lower()
             # Add your project keywords for domain detection
@@ -324,10 +346,20 @@ def process_sensory_register():
                 domain=domain, created_at=event.get("ts", "")
             )
             ingested += 1
+            processed_events += 1
         except Exception as e:
             log(f"  Error embedding: {e}")
+            retained_lines.append(raw_line)
+
+    try:
+        _rewrite_session_buffer(retained_lines)
+    except Exception as e:
+        log(f"  Error rewriting session_buffer: {e}")
 
-    log(f"  Ingested {ingested} sensory events into STM")
+    log(
+        f"  Ingested {ingested} sensory events into STM "
+        f"(processed: {processed_events}, retained: {len(retained_lines)} incl kept={kept_events})"
+    )
 
 
 def analyze_force_events():

package/src/scripts/nexo-reflection.py

@@ -2,8 +2,8 @@
 """
 NEXO Reflection Engine — Processes session_buffer.jsonl entries.
 
-Triggered by the stop hook when >=3 sessions have accumulated and
-the last reflection was >4 hours ago.
+The runtime still ships this as a standalone analyzer, but it is not
+currently auto-triggered by the stop hook.
 
 What it does:
 1. Reads all entries from session_buffer.jsonl