nexo-brain 7.7.0 → 7.8.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.7.0",
+  "version": "7.8.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,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.7.0` is the current packaged-runtime line. Minor release that closes the six gaps left partial after v7.6.0's constructor-guardian-90 pass 1. Gap 1: an autonomous detector now raises `multi_step_task_detected` after three recent Edit/Write/Task calls without a prior `nexo_skill_match` (v7.6 dispatched the event but nothing raised it). Gap 2: the R16 classifier prompt recognises the full done-claim vocabulary (sent / delivered / published / deployed / released / fixed / resolved / merged / pushed plus Spanish equivalents) so the on_event trigger `done_claimed_with_open_task` fires beyond the word "done". Gap 3: R_CATALOG extends to plain `Edit` / `Write` into artefact-bearing paths (skills/, plugins/, personal scripts, `templates/core-prompts/`) and grows its discovery set to include `nexo_personal_scripts_list` + `nexo_plugin_list`. Gap 4: new `R_PRIMITIVE_CHOICE` runtime rule gates Edit/Write of a brand-new artefact without a recent primitive-choice probe (SK-CREATE-NEXO-PRIMITIVE). Gap 5: `guardian_default.json` v1.5.0 raises `R11_plugin_load_pre_inventory` from soft to hard. Gap 6: new `tests/test_v77_enforcement_gaps.py` pins 12 invariants across all six rails. Pytest 2070 passing (+14 vs v7.6.0). Companion release: NEXO Desktop v0.27.0 mirrors the guardian default bumps.
+Version `7.8.1` is the current packaged-runtime line. Patch release that closes 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`.
 
 Previously in `7.6.0`: minor release that closed the drift between `tool-enforcement-map.json` v2.2 and the two enforcement engines (Brain Python + Desktop JS), added per-instance `after_tool` satisfaction, tightened `learning_add` grace to 0 and `task_open` threshold to 4/must, hardened R15/R17/R22/R_CATALOG from soft to hard, and raised R34 from shadow to soft.
 

package/hooks/hooks.json

@@ -76,6 +76,18 @@
         ]
       }
     ],
+    "PostCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "NEXO_HOME=\"${CLAUDE_PLUGIN_DATA}\" NEXO_CODE=\"${CLAUDE_PLUGIN_ROOT}/src\" python3 \"${CLAUDE_PLUGIN_ROOT}/src/hooks/post_compact.py\"",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
     "Notification": [
       {
         "matcher": "*",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.7.0",
+  "version": "7.8.1",
   "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/enforcement_engine.py

@@ -2311,6 +2311,96 @@ class HeadlessEnforcer:
         # v7.6 conditional + deferred on_event reminders.
         self._check_conditional()
         self._check_on_event_pending()
+        # v7.8 — drain hook-emitted events (pre_compaction, post_compaction).
+        self._consume_pending_hook_events()
+
+    def _consume_pending_hook_events(self):
+        """v7.8 / v7.8.1 — drain queued hook events for THIS session only.
+
+        pre-compact.sh and post-compact.sh run in separate processes, so
+        they cannot call `raise_event()` directly. They append one NDJSON
+        row per event to `~/.nexo/runtime/data/pending_enforcer_events.ndjson`.
+
+        v7.8.1 (Francisco correction): the queue is GLOBAL across all
+        concurrent sessions, so the engine MUST filter by `self._session_id`
+        before consuming. The original v7.8 drain read every row, fired
+        `raise_event` for all of them, then truncated the whole file —
+        that let a session A enforcer eat events addressed to session B.
+        The fix:
+
+          * Read all rows.
+          * Split into (mine, others) by comparing row["session_id"] to
+            the engine's own `_session_id`.
+          * Fire `raise_event` for MY rows only.
+          * Rewrite the file with only the OTHERS (plus any rows whose
+            session_id we cannot parse — leave them for the next run).
+
+        This preserves the "no double-fire" invariant and also closes
+        the cross-session consumption bug.
+
+        Fail-closed: any parse/IO error is swallowed so a broken queue
+        cannot crash enforcement.
+        """
+        try:
+            import os
+            nexo_home = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+            queue_path = os.path.join(nexo_home, "runtime", "data", "pending_enforcer_events.ndjson")
+            if not os.path.isfile(queue_path):
+                return
+            import json
+            try:
+                with open(queue_path, "r", encoding="utf-8") as fh:
+                    raw_lines = [ln.rstrip("\n") for ln in fh.readlines()]
+            except Exception:
+                return
+            if not raw_lines:
+                return
+            own_sid = str(self._session_id or "").strip()
+            mine: list[dict] = []
+            keep_raw: list[str] = []
+            for line in raw_lines:
+                s = line.strip()
+                if not s:
+                    continue
+                try:
+                    row = json.loads(s)
+                except Exception:
+                    # Preserve malformed lines so an unrelated parser
+                    # error does not silently drop another session's event.
+                    keep_raw.append(s)
+                    continue
+                row_sid = str((row or {}).get("session_id") or "").strip()
+                if own_sid and row_sid and row_sid == own_sid:
+                    mine.append(row)
+                elif not own_sid:
+                    # Engine has no session id yet (startup edge). Do
+                    # not consume anything — another session might own
+                    # these rows.
+                    keep_raw.append(s)
+                else:
+                    keep_raw.append(s)
+            # Rewrite the file with the rows this session did NOT claim.
+            try:
+                with open(queue_path, "w", encoding="utf-8") as fh:
+                    for kept in keep_raw:
+                        fh.write(kept + "\n")
+            except Exception:
+                # If the rewrite fails we still have the events cached in
+                # `mine`; we just live with a duplicate-risk for the next
+                # read (still bounded — raise_event is itself idempotent
+                # via its dedup tag).
+                pass
+            for row in mine:
+                event = (row or {}).get("event")
+                if not isinstance(event, str) or not event:
+                    continue
+                try:
+                    self.raise_event(event, row)
+                except Exception:
+                    pass
+        except Exception:
+            # Never crash on consumer errors.
+            pass
 
     def _check_on_event_pending(self):
         """Re-evaluate on_event rules with grace > 0 after message ticks.

package/src/hooks/manifest.json

@@ -6,6 +6,7 @@
     { "event": "PreToolUse",       "handler": "src/hooks/pre_tool_use.py",    "critical": true  },
     { "event": "PostToolUse",      "handler": "src/hooks/post_tool_use.py",   "critical": false },
     { "event": "PreCompact",       "handler": "src/hooks/pre_compact.py",     "critical": true  },
+    { "event": "PostCompact",      "handler": "src/hooks/post_compact.py",    "critical": true  },
     { "event": "Stop",             "handler": "src/hooks/stop.py",            "critical": true  },
     { "event": "Notification",     "handler": "src/hooks/notification.py",    "critical": false },
     { "event": "SubagentStop",     "handler": "src/hooks/subagent_stop.py",   "critical": false }

package/src/hooks/post-compact.sh

@@ -22,22 +22,73 @@ if [ -f "$LOG_FILE" ]; then
     LOG_LINES=$(wc -l < "$LOG_FILE" | tr -d ' ')
 fi
 
-# Read checkpoint for the session that just compacted
-# PreCompact writes the SID to /tmp/nexo-compacting-sid
+# v7.8 — Read checkpoint for the EXACT session that compacted. Source
+# of truth is the NEXO_HOME-scoped sidecar PreCompact writes; /tmp is
+# gone (multiple conversations racing on /tmp was the root cause of
+# "otra conversación restauró por accidente"). If the exact SID is not
+# available or maps to a different Claude session than this invocation,
+# we FAIL-CLOSED: print a diagnostic Core Memory Block acknowledging
+# the drop and exit without injecting stale context.
 TARGET_SID=""
-if [ -f /tmp/nexo-compacting-sid ]; then
-    RAW_SID=$(cat /tmp/nexo-compacting-sid 2>/dev/null || echo "")
-    rm -f /tmp/nexo-compacting-sid
-    # Validate SID format: must be nexo-DIGITS-DIGITS
+# v7.8.1 — per-conversation sidecar. If CLAUDE_SESSION_ID is present
+# we read the token-specific file; otherwise (single-conv legacy path)
+# fall back to the global file. Either way, we rm ONLY the file we
+# actually consumed, never another session's.
+SAFE_CLAUDE_ID=""
+if [ -n "${CLAUDE_SESSION_ID:-}" ]; then
+    SAFE_CLAUDE_ID="${CLAUDE_SESSION_ID//[^a-zA-Z0-9._-]/_}"
+    COMPACT_STATE="$DATA_DIR/compacting/$SAFE_CLAUDE_ID.txt"
+else
+    COMPACT_STATE="$DATA_DIR/compacting-sid.txt"
+fi
+if [ -f "$COMPACT_STATE" ]; then
+    RAW_SID=$(cat "$COMPACT_STATE" 2>/dev/null || echo "")
+    rm -f "$COMPACT_STATE"
     if [[ "$RAW_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
         TARGET_SID="$RAW_SID"
     fi
 fi
 
+# Cross-check: the SID we recover MUST belong to the Claude session
+# that fired this hook. If the env ships CLAUDE_SESSION_ID, resolve it
+# to a NEXO SID and require a match with the pre-compact sidecar.
+if [ -f "$NEXO_DB" ] && [ -n "${CLAUDE_SESSION_ID:-}" ]; then
+    ENV_SID=$(sqlite3 "$NEXO_DB" "
+        SELECT sid FROM sessions WHERE claude_session_id = '$CLAUDE_SESSION_ID' LIMIT 1
+    " 2>/dev/null || echo "")
+    if [ -z "$ENV_SID" ]; then
+        ENV_SID=$(sqlite3 "$NEXO_DB" "
+            SELECT sid FROM session_claude_aliases WHERE claude_session_id = '$CLAUDE_SESSION_ID' ORDER BY last_seen DESC LIMIT 1
+        " 2>/dev/null || echo "")
+    fi
+    if [ -n "$TARGET_SID" ] && [ -n "$ENV_SID" ] && [ "$TARGET_SID" != "$ENV_SID" ]; then
+        # Safer to restore nothing than to restore the wrong conv.
+        echo "<!-- NEXO post-compact: SID mismatch (sidecar=$TARGET_SID env=$ENV_SID); skipping rehydration to avoid cross-conv leak. -->"
+        # Still emit a post_compaction event so the engine sees the hook ran.
+        PENDING_EVENTS="$DATA_DIR/pending_enforcer_events.ndjson"
+        python3 -c "
+import json, os, time
+row = {'event': 'post_compaction', 'session_id': os.environ.get('ENV_SID',''),
+       'status': 'mismatch', 'sidecar_sid': os.environ.get('TARGET_SID',''),
+       'claude_session_id': os.environ.get('CLAUDE_SESSION_ID',''),
+       'timestamp': time.time()}
+try:
+    with open(os.environ['PENDING_EVENTS'], 'a', encoding='utf-8') as fh:
+        fh.write(json.dumps(row, ensure_ascii=False) + '\n')
+except Exception: pass
+" ENV_SID="$ENV_SID" TARGET_SID="$TARGET_SID" CLAUDE_SESSION_ID="${CLAUDE_SESSION_ID:-}" PENDING_EVENTS="$PENDING_EVENTS" >/dev/null 2>&1 || true
+        exit 0
+    fi
+    # If the sidecar was missing, trust the env-resolved SID.
+    if [ -z "$TARGET_SID" ] && [ -n "$ENV_SID" ]; then
+        TARGET_SID="$ENV_SID"
+    fi
+fi
+
 CHECKPOINT=""
 if [ -f "$NEXO_DB" ]; then
     if [ -n "$TARGET_SID" ]; then
-        # Read checkpoint for the specific session that compacted
+        # Read checkpoint for the specific session that compacted.
         CHECKPOINT=$(sqlite3 "$NEXO_DB" "
             SELECT sid, task, task_status, active_files, current_goal,
                    decisions_summary, errors_found, reasoning_thread,
@@ -46,16 +97,10 @@ if [ -f "$NEXO_DB" ]; then
             WHERE sid = '$TARGET_SID'
         " 2>/dev/null || echo "")
     fi
-    # Fallback: if no target SID or no checkpoint found, use latest
-    if [ -z "$CHECKPOINT" ]; then
-        CHECKPOINT=$(sqlite3 "$NEXO_DB" "
-            SELECT sid, task, task_status, active_files, current_goal,
-                   decisions_summary, errors_found, reasoning_thread,
-                   next_step, compaction_count
-            FROM session_checkpoints
-            ORDER BY updated_at DESC LIMIT 1
-        " 2>/dev/null || echo "")
-    fi
+    # v7.8: NO MORE latest-checkpoint fallback. Francisco flagged this
+    # explicitly — restoring the wrong conversation is worse than
+    # restoring nothing. We leave CHECKPOINT empty so the "Core memory
+    # block" prints a small diagnostic and exits cleanly.
 
     if [ -n "$CHECKPOINT" ]; then
         # Parse pipe-separated fields
@@ -178,10 +223,13 @@ print('**Guardrail:** skip option menus, reprioritization, summaries, and audits
 }
 HOOKEOF
     else
-        # No checkpoint — fallback to basic message
-        cat << 'HOOKEOF'
+        # v7.8 fail-closed: no checkpoint for the exact SID. We do NOT
+        # inject another conversation's context (that was the pre-v7.8
+        # bug). Minimal diagnostic so the operator can call
+        # nexo_heartbeat with the right SID if they want to continue.
+        cat << HOOKEOF
 {
-  "systemMessage": "Post-compaction: no prior checkpoint found. Call nexo_heartbeat to reconnect session state."
+  "systemMessage": "Post-compaction (SID=${TARGET_SID:-unknown}): no checkpoint for this exact session. Call nexo_heartbeat(sid='${TARGET_SID:-<run nexo_startup>}') to rehydrate — NEXO did NOT restore a different conversation's checkpoint to avoid cross-conv leaks."
 }
 HOOKEOF
     fi
@@ -192,3 +240,25 @@ else
 }
 HOOKEOF
 fi
+
+# v7.8 — emit post_compaction event for the engine consumer.
+PENDING_EVENTS="$DATA_DIR/pending_enforcer_events.ndjson"
+python3 -c "
+import json, os, sys, time
+target = os.environ.get('TARGET_SID', '')
+pending = os.environ.get('PENDING_EVENTS', '')
+if not pending:
+    sys.exit(0)
+row = {
+    'event': 'post_compaction',
+    'session_id': target,
+    'claude_session_id': os.environ.get('CLAUDE_SESSION_ID', ''),
+    'status': 'restored' if target else 'no_target',
+    'timestamp': time.time(),
+}
+try:
+    with open(pending, 'a', encoding='utf-8') as fh:
+        fh.write(json.dumps(row, ensure_ascii=False) + '\n')
+except Exception:
+    pass
+" TARGET_SID="$TARGET_SID" CLAUDE_SESSION_ID="${CLAUDE_SESSION_ID:-}" PENDING_EVENTS="$PENDING_EVENTS" >/dev/null 2>&1 || true

package/src/hooks/post_compact.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""PostCompact unified handler — delegates to post-compact.sh.
+
+The real work (checkpoint lookup, fail-closed cross-conv guard, Core
+Memory Block systemMessage emission, pending-event enqueue) lives in
+the shell script. This wrapper runs it, captures its stdout verbatim
+(so Claude Code gets the systemMessage JSON), and records an entry in
+hook_runs for auditability.
+
+Matches pre_compact.py shape — one .py handler per event so the
+manifest can keep a single clean row per hook type.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+_DIR = Path(__file__).resolve().parent
+
+
+def _record(duration_ms: int, exit_code: int, session_id: str) -> None:
+    try:
+        sys.path.insert(0, str(_DIR.parent))
+        import hook_observability  # type: ignore
+        hook_observability.record_hook_run(
+            "post_compact",
+            duration_ms=duration_ms,
+            exit_code=exit_code,
+            session_id=session_id,
+        )
+    except Exception:
+        pass
+
+
+def main() -> int:
+    started = time.time()
+    script = _DIR / "post-compact.sh"
+    exit_code = 0
+    # Preserve stdout: Claude Code reads the JSON systemMessage line
+    # the shell script prints. We proxy it through so the runtime sees
+    # exactly what post-compact.sh emits.
+    if script.is_file():
+        try:
+            r = subprocess.run(
+                ["bash", str(script)], timeout=15, capture_output=True
+            )
+            if r.stdout:
+                sys.stdout.write(r.stdout.decode("utf-8", errors="replace"))
+                sys.stdout.flush()
+            exit_code = r.returncode
+        except Exception:
+            exit_code = 1
+    _record(
+        int((time.time() - started) * 1000),
+        exit_code,
+        os.environ.get("CLAUDE_SESSION_ID", ""),
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/hooks/pre-compact.sh

@@ -24,34 +24,62 @@ if [ -f "$LOG_FILE" ]; then
     LOG_LINES=$(wc -l < "$LOG_FILE" | tr -d ' ')
 fi
 
-# Enrich checkpoint: copy diary draft context into checkpoint if exists
-if [ -f "$NEXO_DB" ]; then
-    # Get latest active session's diary draft
-    LATEST_SID=$(sqlite3 "$NEXO_DB" "
-        SELECT sid FROM sessions ORDER BY last_update_epoch DESC LIMIT 1
+# v7.8 — Exact session targeting. Claude Code passes the external
+# session token through CLAUDE_SESSION_ID to every hook. We resolve
+# THAT token to the NEXO SID via session_claude_aliases (or direct
+# match on sessions.claude_session_id). LATEST_SID fallback is gone —
+# multi-conversation Desktop made it actively wrong, because the
+# "latest active" session frequently belongs to a different conv than
+# the one Claude Code is compacting in this hook invocation.
+TARGET_SID=""
+if [ -f "$NEXO_DB" ] && [ -n "${CLAUDE_SESSION_ID:-}" ]; then
+    TARGET_SID=$(sqlite3 "$NEXO_DB" "
+        SELECT sid FROM sessions WHERE claude_session_id = '$CLAUDE_SESSION_ID' LIMIT 1
     " 2>/dev/null || echo "")
+    if [ -z "$TARGET_SID" ]; then
+        TARGET_SID=$(sqlite3 "$NEXO_DB" "
+            SELECT sid FROM session_claude_aliases WHERE claude_session_id = '$CLAUDE_SESSION_ID' ORDER BY last_seen DESC LIMIT 1
+        " 2>/dev/null || echo "")
+    fi
+fi
+
+if [ -f "$NEXO_DB" ] && [ -n "$TARGET_SID" ] && [[ "$TARGET_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
+    # v7.8.1 (Francisco correction): the sidecar is per-conversation now.
+    # A single global `compacting-sid.txt` let two near-concurrent
+    # compactions on two different conversations clobber each other's
+    # state. We key the sidecar by the Claude session token that fired
+    # this hook (unique per conversation in Desktop). If the env token
+    # is unset we keep writing the legacy global file so single-conv
+    # callers are unaffected.
+    mkdir -p "$DATA_DIR/compacting" 2>/dev/null || true
+    if [ -n "${CLAUDE_SESSION_ID:-}" ]; then
+        # Sanitise to a filesystem-safe token without paying a subshell
+        # per hook invocation.
+        SAFE_CLAUDE_ID="${CLAUDE_SESSION_ID//[^a-zA-Z0-9._-]/_}"
+        COMPACT_STATE="$DATA_DIR/compacting/$SAFE_CLAUDE_ID.txt"
+    else
+        COMPACT_STATE="$DATA_DIR/compacting-sid.txt"
+    fi
+    printf '%s\n' "$TARGET_SID" > "$COMPACT_STATE"
+
+    # Pull diary draft data into checkpoint for the EXACT session.
+    sqlite3 "$NEXO_DB" "
+        INSERT INTO session_checkpoints (sid, task, current_goal, updated_at)
+        SELECT s.sid, s.task, COALESCE(d.last_context_hint, s.task), datetime('now')
+        FROM sessions s
+        LEFT JOIN session_diary_draft d ON d.sid = s.sid
+        WHERE s.sid = '$TARGET_SID'
+        ON CONFLICT(sid) DO UPDATE SET
+            task = excluded.task,
+            current_goal = CASE
+                WHEN excluded.current_goal != '' THEN excluded.current_goal
+                ELSE session_checkpoints.current_goal
+            END,
+            updated_at = datetime('now')
+    " 2>/dev/null || true
 
-    if [ -n "$LATEST_SID" ] && [[ "$LATEST_SID" =~ ^nexo-[0-9]+-[0-9]+$ ]]; then
-        # Write SID to temp file so PostCompact knows which session compacted
-        echo "$LATEST_SID" > /tmp/nexo-compacting-sid
-        # Pull diary draft data into checkpoint
-        sqlite3 "$NEXO_DB" "
-            INSERT INTO session_checkpoints (sid, task, current_goal, updated_at)
-            SELECT s.sid, s.task, COALESCE(d.last_context_hint, s.task), datetime('now')
-            FROM sessions s
-            LEFT JOIN session_diary_draft d ON d.sid = s.sid
-            WHERE s.sid = '$LATEST_SID'
-            ON CONFLICT(sid) DO UPDATE SET
-                task = excluded.task,
-                current_goal = CASE
-                    WHEN excluded.current_goal != '' THEN excluded.current_goal
-                    ELSE session_checkpoints.current_goal
-                END,
-                updated_at = datetime('now')
-        " 2>/dev/null || true
-
-        # Flush the richer durable checkpoint state if milestone data exists.
-        NEXO_PRECOMPACT_SID="$LATEST_SID" HOOK_DIR="$HOOK_DIR" python3 -c "
+    # Flush the richer durable checkpoint state if milestone data exists.
+    NEXO_PRECOMPACT_SID="$TARGET_SID" HOOK_DIR="$HOOK_DIR" python3 -c "
 import os, sys
 sys.path.insert(0, os.path.abspath(os.path.join(os.environ['HOOK_DIR'], '..')))
 try:
@@ -63,14 +91,43 @@ try:
 except Exception:
     pass
 " 2>/dev/null || true
-    fi
+
+    # v7.8 — enqueue a `pre_compaction` event for the live engine to
+    # consume on the next tool call, so the map's on_event rule fires
+    # from the real stream instead of only via tests.
+    PENDING_EVENTS="$DATA_DIR/pending_enforcer_events.ndjson"
+    python3 -c "
+import json, os, sys, time
+target = os.environ.get('NEXO_PRECOMPACT_SID', '')
+pending = os.environ.get('PENDING_EVENTS', '')
+if not (target and pending):
+    sys.exit(0)
+row = {
+    'event': 'pre_compaction',
+    'session_id': target,
+    'claude_session_id': os.environ.get('CLAUDE_SESSION_ID', ''),
+    'timestamp': time.time(),
+}
+try:
+    with open(pending, 'a', encoding='utf-8') as fh:
+        fh.write(json.dumps(row, ensure_ascii=False) + '\n')
+except Exception:
+    pass
+" NEXO_PRECOMPACT_SID="$TARGET_SID" PENDING_EVENTS="$PENDING_EVENTS" CLAUDE_SESSION_ID="${CLAUDE_SESSION_ID:-}" >/dev/null 2>&1 || true
 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
 
@@ -80,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
@@ -99,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'