nexo-brain 7.25.0 → 7.25.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.25.0",
+  "version": "7.25.1",
   "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.25.0` is the current packaged-runtime line. Minor release over v7.24.0 - Memory Fabric links transcript lookup, historical backup diary recovery, unified search and knowledge graph evidence so memories are not available only inside expiring snapshots.
+Version `7.25.1` is the current packaged-runtime line. Patch release over v7.25.0 - shell guardrails skip non-path curl/wget arguments and daily protocol-debt audits keep ERROR classes visible by severity and type.
+
+Previously in `7.25.0`: minor release over v7.24.0 - Memory Fabric links transcript lookup, historical backup diary recovery, unified search and knowledge graph evidence so memories are not available only inside expiring snapshots.
 
 Previously in `7.24.0`: minor release over v7.23.13 - Home Agents, cognitive quality controls, English operational copy, and non-blocking task-open context are integrated into main.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.25.0",
+  "version": "7.25.2",
   "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/hook_guardrails.py

@@ -76,6 +76,26 @@ SHELL_WRITE_BASES = {
     "rsync",
 }
 SHELL_REDIRECT_TOKENS = {">", ">>", "1>", "1>>", "2>", "2>>"}
+# Flags whose *next* token is a non-path argument (User-Agent strings,
+# headers, query payloads, URLs, etc.). Without this whitelist the bash
+# path extractor lifts fragments like ``Mozilla/5.0`` and ``AppleWebKit/
+# 537.36`` as candidate paths, generating a ``g4_guard_check_required``
+# debt for every curl/wget with a ``-A`` flag. Tracked by NF-AUDIT-
+# 20260522-DRAIN-WHITELIST-EXPAND (W2).
+SHELL_FLAGS_WITH_NON_PATH_ARG = {
+    "-A", "--user-agent",
+    "-H", "--header",
+    "-e", "--referer",
+    "-X", "--request",
+    "-d", "--data", "--data-raw", "--data-binary", "--data-urlencode",
+    "-F", "--form",
+    "-u", "--user",
+    "--url",
+    "--cookie", "-b",
+    "--connect-timeout", "--max-time",
+    "--retry", "--retry-delay", "--retry-max-time",
+    "--resolve",
+}
 INLINE_INTERPRETER_BASES = {
     "python",
     "python3",
@@ -392,6 +412,14 @@ def _looks_like_real_path(path: str) -> bool:
     stripped = raw.lstrip("/")
     if stripped and re.fullmatch(r"\d+", stripped):
         return False
+    # Version-like fragments (``/5.0``, ``/537.36``, ``/140.0.0.0``) come
+    # from User-Agent / library version strings that the EMBEDDED_PATH_RE
+    # scanner lifts out of curl/wget commands. Token-level skip
+    # (SHELL_FLAGS_WITH_NON_PATH_ARG) does not help here because the regex
+    # runs against the raw command string. Filter them out at the path
+    # plausibility check instead.
+    if stripped and re.fullmatch(r"\d+(?:\.\d+)+", stripped):
+        return False
     if raw.lower() in _PATH_DICTIONARY_BLOCKLIST:
         return False
     # Reject single-segment ``/word`` candidates that do not exist on the
@@ -697,12 +725,25 @@ def _extract_bash_touched_files(tool_input) -> list[str]:
             seen.add(normalized)
             candidates.append(resolved)
 
+    skip_next = False
     for index, token in enumerate(tokens):
+        if skip_next:
+            skip_next = False
+            continue
         if token in SHELL_REDIRECT_TOKENS:
             if index + 1 < len(tokens):
                 add(tokens[index + 1])
             continue
         if token.startswith("-"):
+            # ``--flag=value`` is self-contained; the value is glued so the
+            # extractor already ignores it. For the separated form
+            # (``-A "Mozilla/5.0 ..."`` / ``-H "X-Foo: bar"``) we have to
+            # skip the NEXT token, otherwise the path extractor lifts
+            # User-Agent / header / payload fragments as candidate paths
+            # and floods the audit with ``g4_guard_check_required`` noise.
+            flag_head = token.split("=", 1)[0]
+            if flag_head in SHELL_FLAGS_WITH_NON_PATH_ARG and "=" not in token:
+                skip_next = True
             continue
         if (
             token.startswith(("/", "~", ".", "$"))

package/src/plugins/update.py

@@ -280,18 +280,41 @@ def _npm_command_parts() -> tuple[list[str], dict[str, str]]:
     desktop_node = str(os.environ.get("NEXO_DESKTOP_NODE", "")).strip()
     bundled_npm_cli = str(os.environ.get("NEXO_DESKTOP_NPM_CLI", "")).strip()
     env = dict(os.environ)
-    if desktop_node and bundled_npm_cli and Path(desktop_node).exists():
+    if desktop_node and bundled_npm_cli and Path(desktop_node).exists() and Path(bundled_npm_cli).exists():
         env["ELECTRON_RUN_AS_NODE"] = "1"
+        _apply_desktop_npm_prefix(env)
         return [desktop_node, bundled_npm_cli], env
     return ["npm"], env
 
 
+def _desktop_npm_prefix() -> str:
+    return (
+        str(os.environ.get("NEXO_DESKTOP_NPM_PREFIX", "")).strip()
+        or str(os.environ.get("NEXO_CLAUDE_PREFIX", "")).strip()
+        or str(NEXO_HOME / "runtime" / "bootstrap" / "npm-global")
+    )
+
+
+def _apply_desktop_npm_prefix(env: dict[str, str]) -> None:
+    if env.get("ELECTRON_RUN_AS_NODE") != "1":
+        return
+    npm_prefix = _desktop_npm_prefix()
+    if not npm_prefix:
+        return
+    env.setdefault("NPM_CONFIG_PREFIX", npm_prefix)
+    prefix_bin = str(Path(npm_prefix) / "bin")
+    current_path = str(env.get("PATH", ""))
+    entries = [entry for entry in current_path.split(os.pathsep) if entry]
+    env["PATH"] = os.pathsep.join([prefix_bin, *[entry for entry in entries if entry != prefix_bin]])
+
+
 def _run_npm(args: list[str], **kwargs):
     cmd, env = _npm_command_parts()
     extra_env = kwargs.pop("env", None)
     merged_env = dict(env)
     if extra_env:
         merged_env.update(extra_env)
+    _apply_desktop_npm_prefix(merged_env)
     return subprocess.run([*cmd, *args], env=merged_env, **kwargs)
 
 
@@ -1268,7 +1291,7 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     try:
         _emit_progress(progress_fn, "Downloading and applying the latest npm package...")
         result = _run_npm(
-            ["update", "-g", "nexo-brain"],
+            ["install", "-g", "nexo-brain@latest"],
             capture_output=True, text=True, timeout=120,
             env={**os.environ, "NEXO_HOME": str(NEXO_HOME)},
         )

package/src/scripts/deep-sleep/phase_protocol_debt_drain.py

@@ -192,7 +192,7 @@ def run(
             "SELECT id, session_id, task_id, debt_type, severity, evidence, created_at "
             "FROM protocol_debt WHERE resolved_at IS NULL"
         ).fetchall()
-        by_type: dict[str, int] = {}
+        by_severity_type: dict[tuple[str, str], int] = {}
         for row in rows:
             task_open = _task_is_open(conn, str(row["task_id"] or ""))
             bucket = classify_debt(
@@ -216,13 +216,36 @@ def run(
                         ),
                     )
             elif bucket == "requires_user":
-                by_type[str(row["debt_type"])] = by_type.get(str(row["debt_type"]), 0) + 1
-        # Consolidate requires_user into a per-type summary so the morning
-        # briefing stays short even when the backlog is long.
+                # Track by (severity, debt_type) so the morning briefing
+                # can split ERROR vs WARN buckets dynamically — without
+                # this split, freshly-introduced ERROR debt classes stay
+                # invisible until someone hand-edits the whitelist.
+                severity = str(row["severity"] or "warn").strip().lower() or "warn"
+                debt_type = str(row["debt_type"] or "")
+                key = (severity, debt_type)
+                by_severity_type[key] = by_severity_type.get(key, 0) + 1
+        # Consolidate requires_user into a per-severity, per-type summary
+        # so the morning briefing stays short even when the backlog is
+        # long, while still surfacing ALL error classes (not a fixed top-4).
         report["requires_user_summary"] = [
-            {"debt_type": debt_type, "count": count}
-            for debt_type, count in sorted(by_type.items(), key=lambda x: -x[1])
+            {"severity": severity, "debt_type": debt_type, "count": count}
+            for (severity, debt_type), count in sorted(
+                by_severity_type.items(),
+                key=lambda item: (item[0][0] != "error", -item[1]),
+            )
         ]
+        # Aggregate by severity so consumers can report
+        # ``ERROR=N (a=x, b=y), WARN=M`` without re-bucketing.
+        report["requires_user_by_severity"] = {}
+        for entry in report["requires_user_summary"]:
+            sev = entry["severity"]
+            stat = report["requires_user_by_severity"].setdefault(
+                sev, {"total": 0, "by_type": []}
+            )
+            stat["total"] += int(entry["count"])
+            stat["by_type"].append(
+                {"debt_type": entry["debt_type"], "count": int(entry["count"])}
+            )
         if dry_run:
             conn.execute("ROLLBACK")
         else:

package/src/scripts/nexo-daily-self-audit.py

@@ -2102,6 +2102,7 @@ def _run_protocol_debt_drain_inline() -> dict:
         "error": report.get("error", ""),
         "drained_count": len(report.get("drained_ids") or []),
         "requires_user_summary": report.get("requires_user_summary") or [],
+        "requires_user_by_severity": report.get("requires_user_by_severity") or {},
         "audit_path": report.get("audit_path", ""),
     }
 
@@ -2193,11 +2194,45 @@ def run_mechanical_autofixes():
         if debt_drain.get("ok"):
             drained_count = int(debt_drain.get("drained_count") or 0)
             requires_user_summary = debt_drain.get("requires_user_summary") or []
+            requires_user_by_severity = debt_drain.get("requires_user_by_severity") or {}
             if drained_count or requires_user_summary:
                 detail_bits: list[str] = []
                 if drained_count:
                     detail_bits.append(f"drained {drained_count} stale protocol debt item(s)")
-                if requires_user_summary:
+                if requires_user_by_severity:
+                    # Split by severity so ERROR-class debt always appears
+                    # in the morning briefing, regardless of which debt
+                    # types happen to exist that day. Within a severity,
+                    # show every type (no top-N truncation) — silent drift
+                    # is what the previous "top-4" cap was hiding.
+                    severity_order = ["error", "warn", "info"]
+                    seen = set()
+                    severity_bits: list[str] = []
+                    for sev in severity_order + [
+                        s for s in requires_user_by_severity if s not in severity_order
+                    ]:
+                        if sev in seen or sev not in requires_user_by_severity:
+                            continue
+                        seen.add(sev)
+                        stat = requires_user_by_severity[sev]
+                        breakdown = ", ".join(
+                            f"{entry.get('debt_type')}={int(entry.get('count') or 0)}"
+                            for entry in stat.get("by_type") or []
+                        )
+                        label = sev.upper()
+                        if breakdown:
+                            severity_bits.append(
+                                f"{label}={int(stat.get('total') or 0)} ({breakdown})"
+                            )
+                        else:
+                            severity_bits.append(f"{label}={int(stat.get('total') or 0)}")
+                    if severity_bits:
+                        detail_bits.append(
+                            "still needs review: " + " | ".join(severity_bits)
+                        )
+                elif requires_user_summary:
+                    # Defensive fallback: older drain reports without the
+                    # per-severity aggregation still render usefully.
                     summary = ", ".join(
                         f"{item.get('debt_type')} x{int(item.get('count') or 0)}"
                         for item in requires_user_summary[:4]