nexo-brain 1.7.0 → 2.0.0

package/src/cognitive/_decay.py

@@ -254,7 +254,7 @@ def dream_cycle(max_insights: int = 50) -> dict:
         })
 
     if len(recent_memories) < 2:
-        return {"insights_created": 0, "insights": [], "memories_scanned": len(recent_memories)}
+        return {"insights_created": 0, "insights": [], "memories_scanned": len(recent_memories), "candidates_found": 0}
 
     # 2. Get already-dreamed pairs to skip
     dreamed = set()

package/src/cognitive/_search.py

@@ -1,5 +1,6 @@
 """NEXO Cognitive — Search, retrieval, ranking."""
 import math
+import sqlite3
 import numpy as np
 from datetime import datetime
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob, _get_model, _get_reranker, rerank_results, EMBEDDING_DIM

package/src/cognitive/_trust.py

@@ -1,7 +1,7 @@
 """NEXO Cognitive — Trust scoring, sentiment, dissonance."""
 import re
 import numpy as np
-from datetime import datetime
+from datetime import datetime, timedelta
 from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array
 from cognitive._core import POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS
 
@@ -314,13 +314,13 @@ def detect_sentiment(text: str) -> dict:
         sentiment = "negative"
         intensity = min(1.0, 0.3 + neg_score * 0.15)
         if intensity > 0.7:
-            guidance = "MODE: Ultra-conciso. Cero explicaciones. Resolver y mostrar resultado."
+            guidance = "MODE: Ultra-concise. Zero explanations. Solve and show result."
         else:
             guidance = "MODE: Concise. Less context, more direct action."
     elif pos_score > neg_score and pos_score >= 1:
         sentiment = "positive"
         intensity = min(1.0, 0.3 + pos_score * 0.15)
-        guidance = "MODE: Normal. Buen momento para proponer ideas de backlog o mejoras."
+        guidance = "MODE: Normal. Good time to suggest backlog ideas or improvements."
     elif urgency_hits:
         sentiment = "urgent"
         intensity = 0.8

package/src/dashboard/app.py

@@ -10,6 +10,7 @@ Usage:
 import argparse
 import json
 import os
+import platform
 import subprocess
 import sys
 import time
@@ -22,7 +23,7 @@ from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
-# Add parent dir to path so we can import nexo-mcp modules
+# Add parent dir to path so we can import NEXO modules
 _PARENT = str(Path(__file__).resolve().parent.parent)
 if _PARENT not in sys.path:
     sys.path.insert(0, _PARENT)
@@ -63,7 +64,7 @@ async def create_tables():
 
 
 # ---------------------------------------------------------------------------
-# Lazy imports — modules live in the parent nexo-mcp directory
+# Lazy imports — modules live in the parent source directory
 # ---------------------------------------------------------------------------
 
 def _cognitive():
@@ -602,6 +603,11 @@ async def api_ops_execute(fid: str):
         return JSONResponse({"error": f"Followup {fid} not found"}, status_code=404)
     item = dict(row)
     description = item["description"].replace('"', '\\"').replace("'", "\\'")
+    if platform.system() != "Darwin":
+        return JSONResponse(
+            {"error": "This operation requires macOS (uses osascript to open Terminal)"},
+            status_code=501,
+        )
     script = f'tell application "Terminal" to do script "claude \\"NEXO: execute followup #{fid} — {description}\\""'
     subprocess.Popen(["osascript", "-e", script])
     return {"success": True, "followup_id": fid}

package/src/db/_core.py

@@ -9,11 +9,15 @@ import datetime
 import pathlib
 import threading
 
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+_data_dir = os.path.join(NEXO_HOME, "data")
+os.makedirs(_data_dir, exist_ok=True)
+
 DB_PATH = os.environ.get(
     "NEXO_TEST_DB",
     os.environ.get(
         "NEXO_DB",
-        os.path.join(os.path.dirname(os.path.abspath(__file__)), "nexo.db"),
+        os.path.join(_data_dir, "nexo.db"),
     ),
 )
 

package/src/db/_episodic.py

@@ -148,9 +148,7 @@ def update_change_commit(id: int, commit_ref: str) -> dict:
     fts_upsert("change", str(id), r.get("files",""), body, "change_log", commit=False)
 
     # Auto-resolve followups that match this change
-    resolved = auto_resolve_followups(r)
-    if resolved:
-        r["auto_resolved_followups"] = resolved
+    r["_auto_resolved"] = auto_resolve_followups(r)
     return r
 
 

package/src/db/_reminders.py

@@ -134,11 +134,22 @@ def create_followup(id: str, description: str, date: str = None,
                     reasoning: str = '', recurrence: str = None) -> dict:
     """Create a new followup with optional reasoning and recurrence.
 
+    Checks for similar open followups before creating. If a match is found,
+    returns a warning with the existing followup ID (still creates the new one).
+
     recurrence format: 'weekly:monday', 'monthly:1', 'monthly:10', 'quarterly', etc.
     When a recurring followup is completed, a new one is auto-created with the next date.
     """
     conn = get_db()
     now = now_epoch()
+
+    # Anti-duplicate check
+    similar = find_similar_followups(description)
+    warning = ""
+    if similar:
+        ids = ", ".join(s["id"] for s in similar[:3])
+        warning = f" ⚠ SIMILAR FOLLOWUPS EXIST: {ids} (scores: {', '.join(str(s['_similarity']) for s in similar[:3])}). Consider updating instead."
+
     try:
         conn.execute(
             "INSERT INTO followups (id, date, description, verification, status, reasoning, recurrence, created_at, updated_at) "
@@ -150,7 +161,10 @@ def create_followup(id: str, description: str, date: str = None,
     except sqlite3.IntegrityError:
         return {"error": f"Followup {id} already exists. Use update instead."}
     row = conn.execute("SELECT * FROM followups WHERE id = ?", (id,)).fetchone()
-    return dict(row)
+    result = dict(row)
+    if warning:
+        result["warning"] = warning
+    return result
 
 
 def update_followup(id: str, **kwargs) -> dict:
@@ -245,6 +259,18 @@ def complete_followup(id: str, result: str = '') -> dict:
             archived_id = f"{id}-{today}"
             conn.execute("UPDATE followups SET id = ? WHERE id = ?", (archived_id, id))
             conn.commit()
+
+            # Fix FTS: remove old entry for original ID, add entry for archived ID
+            conn.execute("DELETE FROM unified_search WHERE source = 'followup' AND source_id = ?", (id,))
+            archived_row = conn.execute("SELECT * FROM followups WHERE id = ?", (archived_id,)).fetchone()
+            if archived_row:
+                fts_upsert(
+                    "followup", archived_id, archived_id,
+                    f"{archived_row['description']} {archived_row['verification'] or ''} {archived_row['reasoning'] or ''}",
+                    "followup", commit=False,
+                )
+
+            # create_followup handles its own FTS entry for the new recurring ID
             create_followup(
                 id=id,
                 description=row["description"],
@@ -254,6 +280,15 @@ def complete_followup(id: str, result: str = '') -> dict:
                 recurrence=recurrence,
             )
 
+            # Return accurate result: the completed one is now archived_id, not id
+            return {
+                "id": archived_id,
+                "status": "COMPLETED",
+                "recurrence": recurrence,
+                "next_id": id,
+                "next_date": next_date,
+            }
+
     return update_result
 
 

package/src/db/_schema.py

@@ -265,6 +265,36 @@ def _m14_learnings_priority_weight(conn):
     _migrate_add_column(conn, "followups", "priority", "TEXT DEFAULT 'medium'")
 
 
+def _m15_core_rules_tables(conn):
+    """Core rules and version tracking tables for the core_rules plugin."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS core_rules (
+            id TEXT PRIMARY KEY,
+            category TEXT NOT NULL,
+            rule TEXT NOT NULL,
+            why TEXT NOT NULL,
+            importance INTEGER NOT NULL DEFAULT 3,
+            type TEXT NOT NULL DEFAULT 'advisory',
+            added_in TEXT DEFAULT '',
+            removed_in TEXT DEFAULT NULL,
+            is_active INTEGER NOT NULL DEFAULT 1
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS core_rules_version (
+            id INTEGER PRIMARY KEY,
+            version TEXT NOT NULL DEFAULT '0.0.0',
+            updated_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    # Seed the version row so UPDATE statements in the plugin always find it
+    conn.execute(
+        "INSERT OR IGNORE INTO core_rules_version (id, version) VALUES (1, '0.0.0')"
+    )
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_category ON core_rules(category)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_active ON core_rules(is_active)")
+
+
 # Migration registry — APPEND ONLY, never reorder or delete
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
@@ -281,6 +311,7 @@ MIGRATIONS = [
     (12, "session_checkpoints", _m12_session_checkpoints),
     (13, "claude_session_id", _m13_claude_session_id),
     (14, "learnings_priority_weight", _m14_learnings_priority_weight),
+    (15, "core_rules_tables", _m15_core_rules_tables),
 ]
 
 

package/src/evolution_cycle.py

@@ -14,14 +14,22 @@ import time
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-NEXO_DB = Path.home() / ".nexo" / "nexo-mcp" / "nexo.db"
-CORTEX_DIR = Path(__file__).parent
-CLAUDE_DIR = Path.home() / ".nexo"
-SANDBOX_DIR = CLAUDE_DIR / "sandbox" / "workspace"
-SNAPSHOTS_DIR = CLAUDE_DIR / "snapshots"
-OBJECTIVE_FILE = CORTEX_DIR / "evolution-objective.json"
-PROMPT_FILE = CORTEX_DIR / "evolution-prompt.md"
-RESTORE_LOG = CLAUDE_DIR / "logs" / "snapshot-restores.log"
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(NEXO_HOME)))
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+SANDBOX_DIR = NEXO_HOME / "sandbox" / "workspace"
+SNAPSHOTS_DIR = NEXO_HOME / "snapshots"
+RESTORE_LOG = NEXO_HOME / "logs" / "snapshot-restores.log"
+
+# Evolution config: brain/ (canonical) > cortex/ (legacy) > NEXO_CODE (dev)
+def _resolve_evolution_file(name: str) -> Path:
+    for candidate in [NEXO_HOME / "brain" / name, NEXO_HOME / "cortex" / name, NEXO_CODE / name]:
+        if candidate.exists():
+            return candidate
+    return NEXO_HOME / "brain" / name  # default canonical path
+
+OBJECTIVE_FILE = _resolve_evolution_file("evolution-objective.json")
+PROMPT_FILE = _resolve_evolution_file("evolution-prompt.md")
 
 MAX_SNAPSHOTS = 8
 
@@ -105,6 +113,8 @@ def create_snapshot(files_to_backup: list) -> str:
             rel = str(fp).replace(str(Path.home()) + "/", "")
             dest = files_dir / rel
             dest.parent.mkdir(parents=True, exist_ok=True)
+            if os.path.abspath(str(fp)) == os.path.abspath(str(dest)):
+                continue  # Skip: source and destination are the same file
             shutil.copy2(fp, dest)
             manifest["files"].append(rel)
 
@@ -144,9 +154,21 @@ def dry_run_restore_test() -> bool:
 
     test_file.write_text("modified_content")
 
+    # Find restore script: NEXO_CODE/scripts/ first, then NEXO_HOME/scripts/
+    _nexo_code = Path(os.environ.get("NEXO_CODE", ""))
+    restore_script = None
+    for candidate in [_nexo_code / "scripts" / "nexo-snapshot-restore.sh",
+                      NEXO_HOME / "scripts" / "nexo-snapshot-restore.sh"]:
+        if candidate.exists():
+            restore_script = candidate
+            break
+    if not restore_script:
+        test_file.unlink(missing_ok=True)
+        return False  # No restore script available
+
     try:
         subprocess.run(
-            [str(CLAUDE_DIR / "scripts" / "nexo-snapshot-restore.sh"), snap_dir],
+            [str(restore_script), snap_dir],
             capture_output=True, timeout=10, check=True
         )
         content = test_file.read_text()
@@ -200,7 +222,7 @@ INVESTIGATE using these tools:
 4. Read ~/.nexo/coordination/postmortem-daily.md — self-critique patterns
 5. Read ~/.nexo/logs/self-audit-summary.json — system health
 6. Glob ~/.nexo/scripts/*.py — existing scripts
-7. Glob ~/.nexo/nexo-mcp/plugins/*.py — existing plugins
+7. Glob ~/.nexo/plugins/*.py — existing plugins
 
 LOOK FOR:
 - Repeated errors that guard isn't preventing
@@ -210,7 +232,7 @@ LOOK FOR:
 - Patterns in self-critique that suggest systemic issues
 
 SAFETY:
-- Safe zones for auto changes: ~/.nexo/scripts/, ~/.nexo/nexo-mcp/plugins/, ~/.nexo/cortex/
+- Safe zones for auto changes: ~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/
 - IMMUTABLE files (never touch): db.py, server.py, plugin_loader.py, cognitive.py, CLAUDE.md
 - Every change needs: what file, what to change, why, risk, how to verify
 

package/src/hooks/auto_capture.py

@@ -17,7 +17,7 @@ import re
 import sys
 from pathlib import Path
 
-# Add nexo-mcp to path for cognitive imports
+# Add source dir to path for cognitive imports
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 import cognitive
 

package/src/hooks/capture-tool-logs.sh

@@ -40,6 +40,82 @@ record = {
 print(json.dumps(record))
 " >> "$LOG_FILE" 2>/dev/null
 
+# ── Layer 1: Auto-diary every 10 tool calls ─────────────────────────
+COUNTER_FILE="$NEXO_HOME/operations/.tool-call-count"
+NEXO_DB="$NEXO_HOME/data/nexo.db"
+
+# Increment counter (atomic: read+write in one step)
+COUNT=1
+if [ -f "$COUNTER_FILE" ]; then
+    COUNT=$(( $(cat "$COUNTER_FILE" 2>/dev/null || echo 0) + 1 ))
+fi
+echo "$COUNT" > "$COUNTER_FILE"
+
+# Every 10 tool calls, write a mechanical diary draft to SQLite
+if [ $(( COUNT % 10 )) -eq 0 ] && [ -f "$NEXO_DB" ]; then
+    python3 -c "
+import json, sqlite3, os, sys
+from datetime import datetime
+
+db_path = '$NEXO_DB'
+log_file = '$LOG_FILE'
+count = $COUNT
+
+# Read last 10 tool calls from today's log
+entries = []
+if os.path.isfile(log_file):
+    with open(log_file, 'r') as f:
+        lines = f.readlines()
+        for line in lines[-10:]:
+            try:
+                e = json.loads(line.strip())
+                name = e.get('tool_name', '?')
+                inp = e.get('tool_input', {})
+                # Brief args: first key's value, truncated
+                brief = ''
+                if isinstance(inp, dict):
+                    for k, v in list(inp.items())[:1]:
+                        brief = str(v)[:60]
+                entries.append(f'{name}({brief})')
+            except Exception:
+                pass
+
+if not entries:
+    sys.exit(0)
+
+tools_summary = ', '.join(entries[-10:])
+
+# Get current session and task from sessions table
+conn = sqlite3.connect(db_path, timeout=2)
+conn.row_factory = sqlite3.Row
+row = conn.execute(
+    'SELECT sid, task FROM sessions ORDER BY last_update_epoch DESC LIMIT 1'
+).fetchone()
+if not row:
+    conn.close()
+    sys.exit(0)
+
+sid = row['sid']
+task = row['task'] or 'unknown'
+
+summary = f'[AUTO-{count}] {len(entries)} tool calls: {tools_summary[:250]}. Task: {task[:100]}'
+
+# Write to session_diary_draft (UPSERT)
+conn.execute('''
+    INSERT INTO session_diary_draft (sid, summary_draft, tasks_seen, change_ids, decision_ids, last_context_hint, heartbeat_count, updated_at)
+    VALUES (?, ?, '[]', '[]', '[]', ?, 0, datetime('now'))
+    ON CONFLICT(sid) DO UPDATE SET
+        summary_draft = excluded.summary_draft,
+        last_context_hint = excluded.last_context_hint,
+        updated_at = datetime('now')
+''', (sid, summary, f'auto-diary at {count} tool calls'))
+conn.commit()
+conn.close()
+" 2>/dev/null &
+    # Reset counter after writing
+    echo "0" > "$COUNTER_FILE"
+fi
+
 # Cleanup: delete logs >= 30 days old (once daily, uses marker file)
 CLEANUP_MARKER="$LOG_DIR/.last-cleanup"
 if [ ! -f "$CLEANUP_MARKER" ] || [ "$(cat "$CLEANUP_MARKER" 2>/dev/null)" != "$TODAY" ]; then

package/src/hooks/inbox-hook.sh

@@ -27,7 +27,8 @@ echo "$NOW" > "$DEBOUNCE_FILE"
 
 # 4. Find NEXO SID mapped to this Claude session_id
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-DB="$NEXO_HOME/nexo.db"
+DB="$NEXO_HOME/data/nexo.db"
+mkdir -p "$NEXO_HOME/data"
 [ -f "$DB" ] || exit 0
 
 NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE claude_session_id = '${CLAUDE_SID}' AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)

package/src/hooks/post-compact.sh

@@ -5,7 +5,8 @@
 set -euo pipefail
 
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-NEXO_DB="$NEXO_HOME/nexo.db"
+NEXO_DB="$NEXO_HOME/data/nexo.db"
+mkdir -p "$NEXO_HOME/data"
 TODAY=$(date +%Y-%m-%d)
 LOG_FILE="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
 LOG_LINES=0

package/src/hooks/pre-compact.sh

@@ -6,7 +6,8 @@
 set -euo pipefail
 
 NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-NEXO_DB="$NEXO_HOME/nexo.db"
+NEXO_DB="$NEXO_HOME/data/nexo.db"
+mkdir -p "$NEXO_HOME/data"
 TODAY=$(date +%Y-%m-%d)
 LOG_FILE="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
 LOG_LINES=0
@@ -42,8 +43,109 @@ if [ -f "$NEXO_DB" ]; then
     fi
 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 "
+import json, sqlite3, os, sys
+from datetime import datetime
+
+db_path = '$NEXO_DB'
+log_file = '$LOG_FILE'
+
+conn = sqlite3.connect(db_path, timeout=3)
+conn.row_factory = sqlite3.Row
+
+# Get latest active session
+row = conn.execute(
+    'SELECT sid, task FROM sessions ORDER BY last_update_epoch DESC LIMIT 1'
+).fetchone()
+if not row:
+    conn.close()
+    sys.exit(0)
+
+sid = row['sid']
+task = row['task'] or 'unknown'
+
+# Check if a real diary already exists for this session
+has_diary = conn.execute(
+    'SELECT id FROM session_diary WHERE session_id = ? LIMIT 1', (sid,)
+).fetchone()
+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
+last_diary = conn.execute(
+    'SELECT created_at FROM session_diary ORDER BY created_at DESC LIMIT 1'
+).fetchone()
+last_diary_ts = last_diary['created_at'] if last_diary else '1970-01-01T00:00:00Z'
+
+# Read tool log entries since last diary
+entries = []
+modified_files = []
+git_actions = []
+if os.path.isfile(log_file):
+    with open(log_file, 'r') as f:
+        for line in f:
+            try:
+                e = json.loads(line.strip())
+                ts = e.get('timestamp', '')
+                if ts < last_diary_ts:
+                    continue
+                name = e.get('tool_name', '?')
+                inp = e.get('tool_input', {}) or {}
+                brief = ''
+                if isinstance(inp, dict):
+                    for k, v in list(inp.items())[:1]:
+                        brief = str(v)[:80]
+                entries.append(f'{name}({brief})')
+                # Extract decisions from tool calls
+                if name in ('Edit', 'Write'):
+                    fp = inp.get('file_path', inp.get('path', ''))
+                    if fp:
+                        modified_files.append(fp.split('/')[-1])
+                if name == 'Bash':
+                    cmd = str(inp.get('command', ''))
+                    if 'git commit' in cmd or 'git push' in cmd:
+                        git_actions.append(cmd[:80])
+            except Exception:
+                pass
+
+if not entries:
+    conn.close()
+    sys.exit(0)
+
+# Build mechanical diary
+tools_summary = ', '.join(entries[-30:])[:500]
+summary = f'[EMERGENCY PRE-COMPACT] {len(entries)} tool calls since last diary. Tools: {tools_summary}'
+
+decisions = ''
+if modified_files:
+    decisions = 'Modified: ' + ', '.join(set(modified_files))[:300]
+if git_actions:
+    decisions += (' | Git: ' + ', '.join(git_actions))[:200]
+if not decisions:
+    decisions = 'No file modifications detected in tool logs'
+
+pending = f'Current task: {task[:200]}'
+context_next = 'COMPACTION HAPPENED. Read this diary to continue. Check session_checkpoints and tool-logs for full context.'
+
+# Write actual session_diary entry
+conn.execute('''
+    INSERT INTO session_diary
+        (session_id, decisions, discarded, pending, context_next,
+         mental_state, domain, user_signals, summary, source)
+    VALUES (?, ?, '', ?, ?, 'auto-generated', 'auto', '', ?, 'pre-compact-hook')
+''', (sid, decisions, pending, context_next, summary))
+conn.commit()
+conn.close()
+" 2>/dev/null || true
+fi
+
 cat << HOOKEOF
 {
-  "systemMessage": "CONTEXT IS ABOUT TO BE COMPRESSED.\n\nOBLIGATORY ACTIONS BEFORE COMPACTION:\n1. Save critical state via MCP: nexo_checkpoint_save with current task, active files, decisions, errors, next step, and reasoning thread.\n2. If there is work in progress without a commit, save data via nexo_entity_create, nexo_preference_set, nexo_learning_add, nexo_followup_create.\n3. PERSISTENT TOOL LOGS: ${NEXO_HOME}/operations/tool-logs/${TODAY}.jsonl has ${LOG_LINES} entries.\n4. After compaction, the PostCompact hook will re-inject a Core Memory Block with the checkpoint.\n5. MCP tools (nexo_*) preserve all state — use them to recover context."
+  "systemMessage": "CONTEXT IS ABOUT TO BE COMPRESSED.\n\nOBLIGATORY ACTIONS BEFORE COMPACTION:\n1. Save critical state via MCP: nexo_checkpoint_save with current task, active files, decisions, errors, next step, and reasoning thread.\n2. If there is work in progress without a commit, save data via nexo_entity_create, nexo_preference_set, nexo_learning_add, nexo_followup_create.\n3. PERSISTENT TOOL LOGS: ${NEXO_HOME}/operations/tool-logs/${TODAY}.jsonl has ${LOG_LINES} entries.\n4. After compaction, the PostCompact hook will re-inject a Core Memory Block with the checkpoint.\n5. MCP tools (nexo_*) preserve all state — use them to recover context.\n6. EMERGENCY DIARY: An automatic diary was written by the pre-compact hook. The LLM can still write a better one via nexo_session_diary_write."
 }
 HOOKEOF