nexo-brain 7.8.0 → 7.8.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.8.0",
+  "version": "7.8.2",
   "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.8.0` is the current packaged-runtime line. Minor release that closes the PostCompact continuity work Francisco requested after v7.7: `src/hooks/post_compact.py` is a real registered hook (part of the canonical 9-hook set, was 8), `pre-compact.sh` resolves the exact NEXO SID from `CLAUDE_SESSION_ID` instead of falling back to "latest active session" (that was actively wrong in multi-conversation Desktop), the sidecar moves from `/tmp` to `$NEXO_HOME/runtime/data/compacting-sid.txt` so two concurrent compactions on two conversations cannot race on `/tmp`, `post-compact.sh` removes its "latest checkpoint" fallback (fail-closed to a diagnostic systemMessage instead of restoring the wrong conversation), and the hook cross-checks the sidecar SID against the env-resolved one so a "SID mismatch" is logged as such. Pre- and post-compact now emit NDJSON events the engine drains on every periodic tick via `_consume_pending_hook_events()`; the queue file is truncated after read so an event never fires twice. A new contract test (`tests/test_v78_compaction_continuity.py`) pins 11 invariants across ten rails including the hook registration, the exact-SID resolution path, fail-closed behaviour, and that `compaction_count` only increments on real restore. Pytest 2086 passing (+16 vs v7.7). No Desktop bump — v0.27.0 continues to ship.
+Version `7.8.2` is the current packaged-runtime line. Patch release that fixes the compact-hook observability gap Francisco flagged after v7.8.1: `hook_runs.session_id` was empty for 7 out of 8 recent compaction rows (and when populated it stored the raw Claude Code token instead of the NEXO sid), so per-session queries over `hook_runs` for compact events could not be joined back to the NEXO session that actually compacted. v7.8.2 adds `src/hooks/compact_session_resolver.py` with `resolve_nexo_sid(claude_session_id)`, which walks the same rails the shell already uses: `sessions.claude_session_id` match, then `session_claude_aliases.claude_session_id` (most recent `last_seen` wins), then the per-conversation sidecar under `runtime/data/compacting/<safe-claude-id>.txt`, then the legacy global sidecar for single-conversation setups. `src/hooks/pre_compact.py` and `src/hooks/post_compact.py` now call the resolver and store the real NEXO sid in `hook_runs.session_id`; both wrappers also stash `{claude_session_id, sid_source}` in `hook_runs.metadata` so "why is this row still empty?" has a one-query answer. Nine new tests in `tests/test_hook_runs_compact_sid_resolution.py` pin the five resolver rails (sessions / alias / sidecar / legacy / none), malformed-sidecar rejection, the pre- and post-compact wrapper end-to-end paths, and the empty-state wrapper rail so a clean audit trail is written even when nothing resolves. No Desktop bump.
+
+Previously in `7.8.1`: patch release that closed the last compaction-continuity gap Francisco flagged after v7.8.0: `pre-compact.sh` Layer 2 emergency auto-diary and Layer 3 `compaction_memory.record_auto_flush` now use the exact `TARGET_SID` resolved from `CLAUDE_SESSION_ID` instead of falling back to `ORDER BY last_update_epoch DESC LIMIT 1` ("latest active session"). In multi-conversation Desktop that fallback routinely wrote the emergency diary against the wrong conversation even though the main restore path was already exact-SID in v7.8.0. `last_diary_ts` is also scoped by `session_id` now. Fail-closed when no `CLAUDE_SESSION_ID` resolves. New behavioural tests drive the real shell script with two sessions in the DB to pin the invariant. Fixed a latent bash-escape bug in `pre-compact.sh` where a double-quoted string inside a Python comment silently closed the `python3 -c "..."` argument early — caught by adding the behavioural tests. Pytest 2092 passing (+2 new behavioural). No Desktop bump.
+
+Previously in `7.8.0`: minor release that closed the PostCompact continuity work Francisco requested after v7.7: `src/hooks/post_compact.py` is a real registered hook (part of the canonical 9-hook set, was 8), `pre-compact.sh` resolves the exact NEXO SID from `CLAUDE_SESSION_ID` instead of falling back to "latest active session" (that was actively wrong in multi-conversation Desktop), the sidecar moves from `/tmp` to `$NEXO_HOME/runtime/data/compacting-sid.txt` so two concurrent compactions on two conversations cannot race on `/tmp`, `post-compact.sh` removes its "latest checkpoint" fallback (fail-closed to a diagnostic systemMessage instead of restoring the wrong conversation), and the hook cross-checks the sidecar SID against the env-resolved one so a "SID mismatch" is logged as such. Pre- and post-compact now emit NDJSON events the engine drains on every periodic tick via `_consume_pending_hook_events()`; the queue file is truncated after read so an event never fires twice. A new contract test (`tests/test_v78_compaction_continuity.py`) pins 11 invariants across ten rails including the hook registration, the exact-SID resolution path, fail-closed behaviour, and that `compaction_count` only increments on real restore. Pytest 2086 passing (+16 vs v7.7). No Desktop bump — v0.27.0 continues to ship.
 
 Previously in `7.7.0`: minor release that closed the six gaps left partial after v7.6.0's constructor-guardian-90 pass 1 (autonomous detector for `multi_step_task_detected`, R16 vocabulary expansion, R_CATALOG extended to plain Edit/Write, new `R_PRIMITIVE_CHOICE` rule, `R11_plugin_load_pre_inventory` hardened, 12 new contract tests). Post-review hotfix on the same release wired `task_open` rearm properly (discarded from `tools_called` + per-instance pin cleared on `task_close`), added live `on_event` triggers in R14 and R16, and called `on_tool_call_before` before `on_tool_call` in `run_with_enforcement` so before_tool rules fire in Brain the same way Desktop fires `onBeforeToolCall`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.8.0",
+  "version": "7.8.2",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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/hooks/compact_session_resolver.py

@@ -0,0 +1,135 @@
+"""Resolve the NEXO sid for compaction hook observability.
+
+`hook_runs.session_id` must hold the NEXO sid (`nexo-NNNNNN-N`) so that a
+query like "every compaction of session X" works without joining on the
+raw Claude Code token. Pre-v7.8.2 the two Python wrappers stored
+`os.environ.get("CLAUDE_SESSION_ID", "")` directly, which produced two
+problems at once: rows with `session_id=''` when the env was missing,
+and rows with the raw Claude token (not a NEXO sid) when it was
+present. This helper centralises the resolution against the same rails
+the shell scripts use.
+
+Resolution order:
+  1. ENV `CLAUDE_SESSION_ID` with `sessions.claude_session_id` match.
+  2. ENV `CLAUDE_SESSION_ID` with `session_claude_aliases.claude_session_id`
+     match (most recent `last_seen` wins).
+  3. Per-conversation sidecar written by pre-compact.sh at
+     the compacting folder under the runtime data dir.
+  4. Legacy global sidecar at compacting-sid.txt (single-conv legacy path).
+
+Returns (nexo_sid, source) so the caller can stash `source` in the
+`hook_runs.metadata` JSON for debugging "why is this row still empty".
+"""
+from __future__ import annotations
+
+import os
+import re
+import sqlite3
+from pathlib import Path
+
+_NEXO_SID_RE = re.compile(r"^nexo-[0-9]+-[0-9]+$")
+_SAFE_CLAUDE_ID_RE = re.compile(r"[^a-zA-Z0-9._-]")
+
+
+def _nexo_home() -> Path:
+    return Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+
+def _candidate_data_dirs() -> list[Path]:
+    home = _nexo_home()
+    dirs: list[Path] = []
+    for cand in (home / "runtime" / "data", home / "data"):
+        if cand not in dirs:
+            dirs.append(cand)
+    return dirs
+
+
+def _db_path() -> Path | None:
+    for d in _candidate_data_dirs():
+        p = d / "nexo.db"
+        if p.is_file():
+            return p
+    return None
+
+
+def _safe_claude_id(claude_session_id: str) -> str:
+    return _SAFE_CLAUDE_ID_RE.sub("_", claude_session_id or "")
+
+
+def _read_sidecar(path: Path) -> str:
+    try:
+        text = path.read_text(encoding="utf-8").strip()
+    except Exception:
+        return ""
+    return text if _NEXO_SID_RE.match(text) else ""
+
+
+def _db_lookup(claude_session_id: str) -> tuple[str, str]:
+    if not claude_session_id:
+        return "", ""
+    db = _db_path()
+    if db is None:
+        return "", ""
+    try:
+        conn = sqlite3.connect(str(db), timeout=3)
+    except Exception:
+        return "", ""
+    try:
+        try:
+            row = conn.execute(
+                "SELECT sid FROM sessions WHERE claude_session_id = ? LIMIT 1",
+                (claude_session_id,),
+            ).fetchone()
+        except Exception:
+            row = None
+        if row and row[0] and _NEXO_SID_RE.match(row[0]):
+            return row[0], "sessions"
+        try:
+            row = conn.execute(
+                "SELECT sid FROM session_claude_aliases "
+                "WHERE claude_session_id = ? "
+                "ORDER BY last_seen DESC LIMIT 1",
+                (claude_session_id,),
+            ).fetchone()
+        except Exception:
+            row = None
+        if row and row[0] and _NEXO_SID_RE.match(row[0]):
+            return row[0], "alias"
+    finally:
+        try:
+            conn.close()
+        except Exception:
+            pass
+    return "", ""
+
+
+def resolve_nexo_sid(claude_session_id: str = "") -> tuple[str, str]:
+    """Resolve the NEXO sid for the current compaction invocation.
+
+    Returns ``(nexo_sid, source)`` where ``source`` is one of:
+
+    - ``sessions``       resolved via sessions table claude_session_id.
+    - ``alias``          resolved via session_claude_aliases.
+    - ``sidecar``        per-conversation sidecar file.
+    - ``sidecar_legacy`` legacy global sidecar (single-conv path).
+    - ``none``           no rail matched; caller stores empty string.
+    """
+    token = (claude_session_id or os.environ.get("CLAUDE_SESSION_ID", "") or "").strip()
+
+    if token:
+        sid, source = _db_lookup(token)
+        if sid:
+            return sid, source
+        safe_id = _safe_claude_id(token)
+        if safe_id:
+            for base in _candidate_data_dirs():
+                side = _read_sidecar(base / "compacting" / f"{safe_id}.txt")
+                if side:
+                    return side, "sidecar"
+
+    for base in _candidate_data_dirs():
+        side = _read_sidecar(base / "compacting-sid.txt")
+        if side:
+            return side, "sidecar_legacy"
+
+    return "", "none"

package/src/hooks/post_compact.py

@@ -22,15 +22,30 @@ from pathlib import Path
 _DIR = Path(__file__).resolve().parent
 
 
-def _record(duration_ms: int, exit_code: int, session_id: str) -> None:
+def _record(duration_ms: int, exit_code: int, claude_session_id: str) -> None:
+    """Log a hook_runs row with the resolved NEXO sid.
+
+    v7.8.2 — see the matching docstring in pre_compact.py. Post-compact
+    runs after the shell script has already consumed the per-conv
+    sidecar, but the DB rails (sessions/aliases) stay valid, so the
+    resolver still returns a sid in the common case. `sid_source` goes
+    into metadata for empty-row triage.
+    """
     try:
         sys.path.insert(0, str(_DIR.parent))
+        sys.path.insert(0, str(_DIR))
         import hook_observability  # type: ignore
+        from compact_session_resolver import resolve_nexo_sid  # type: ignore
+        nexo_sid, sid_source = resolve_nexo_sid(claude_session_id)
         hook_observability.record_hook_run(
             "post_compact",
             duration_ms=duration_ms,
             exit_code=exit_code,
-            session_id=session_id,
+            session_id=nexo_sid,
+            metadata={
+                "claude_session_id": claude_session_id,
+                "sid_source": sid_source,
+            },
         )
     except Exception:
         pass

package/src/hooks/pre-compact.sh

@@ -117,10 +117,17 @@ except Exception:
 fi
 
 # ── Layer 2: Emergency auto-diary before compaction ──────────────────
-# Write an actual session_diary entry (not draft) with mechanical summary
-# This is the parachute — if the LLM never wrote a diary, at least this exists
-if [ -f "$NEXO_DB" ]; then
-    python3 -c "
+# Write an actual session_diary entry (not draft) with mechanical summary.
+# This is the parachute — if the LLM never wrote a diary, at least this exists.
+#
+# v7.8.1 hotfix: must target the EXACT session compacting. Pre-v7.8.1 used
+# "latest active session" (ORDER BY last_update_epoch DESC LIMIT 1) which in
+# multi-conversation Desktop routinely wrote the diary onto the wrong conv.
+# Now we read TARGET_SID resolved from CLAUDE_SESSION_ID above. If it is
+# missing or does not exist in sessions, we fail-closed: no emergency diary
+# > wrong emergency diary. Layer 3 auto_flush is wired to the same SID.
+if [ -f "$NEXO_DB" ] && [ -n "$TARGET_SID" ] && [[ "$TARGET_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
+    NEXO_PRECOMPACT_SID="$TARGET_SID" python3 -c "
 import json, sqlite3, os, sys
 from datetime import datetime
 
@@ -130,15 +137,21 @@ log_file = '$LOG_FILE'
 conn = sqlite3.connect(db_path, timeout=3)
 conn.row_factory = sqlite3.Row
 
-# Get latest active session
+# v7.8.1 — use the EXACT SID resolved by Layer 1 (from CLAUDE_SESSION_ID),
+# not the pre-v7.8 latest-active row which routinely belongs to a
+# different conversation.
+sid = os.environ.get('NEXO_PRECOMPACT_SID', '')
+if not sid:
+    conn.close()
+    sys.exit(0)
 row = conn.execute(
-    'SELECT sid, task FROM sessions ORDER BY last_update_epoch DESC LIMIT 1'
+    'SELECT sid, task FROM sessions WHERE sid = ? LIMIT 1', (sid,)
 ).fetchone()
 if not row:
+    # SID not present — fail-closed, better skip than write against the
+    # wrong session.
     conn.close()
     sys.exit(0)
-
-sid = row['sid']
 task = row['task'] or 'unknown'
 
 # Check if a real diary already exists for this session
@@ -149,9 +162,12 @@ if has_diary:
     conn.close()
     sys.exit(0)  # LLM already wrote one, no need for emergency diary
 
-# Find last diary timestamp to know where to start reading logs
+# v7.8.1 — last_diary_ts must be scoped to THIS session too. Otherwise
+# a recent diary of another conversation would truncate this conv's
+# mechanical summary window.
 last_diary = conn.execute(
-    'SELECT created_at FROM session_diary ORDER BY created_at DESC LIMIT 1'
+    'SELECT created_at FROM session_diary WHERE session_id = ? ORDER BY created_at DESC LIMIT 1',
+    (sid,),
 ).fetchone()
 last_diary_ts = last_diary['created_at'] if last_diary else '1970-01-01T00:00:00Z'
 

package/src/hooks/pre_compact.py

@@ -18,14 +18,33 @@ _DIR = Path(__file__).resolve().parent
 
 
 def _record(duration_ms: int, exit_code: int) -> None:
+    """Log a hook_runs row with the resolved NEXO sid.
+
+    v7.8.2 — the raw `CLAUDE_SESSION_ID` env token is not a NEXO sid, so
+    storing it in `hook_runs.session_id` made per-session queries useless
+    and left the column empty whenever Claude Code did not forward the
+    env. `compact_session_resolver.resolve_nexo_sid` walks the same
+    rails the shell script uses (sessions → aliases → per-conv sidecar
+    → legacy global sidecar) and returns `(nexo_sid, source)`. The raw
+    Claude token and the resolution source end up in `metadata` so an
+    operator can debug why a given row is still empty.
+    """
     try:
         sys.path.insert(0, str(_DIR.parent))
+        sys.path.insert(0, str(_DIR))
         import hook_observability  # type: ignore
+        from compact_session_resolver import resolve_nexo_sid  # type: ignore
+        claude_id = os.environ.get("CLAUDE_SESSION_ID", "")
+        nexo_sid, sid_source = resolve_nexo_sid(claude_id)
         hook_observability.record_hook_run(
             "pre_compact",
             duration_ms=duration_ms,
             exit_code=exit_code,
-            session_id=os.environ.get("CLAUDE_SESSION_ID", ""),
+            session_id=nexo_sid,
+            metadata={
+                "claude_session_id": claude_id,
+                "sid_source": sid_source,
+            },
         )
     except Exception:
         pass