nexo-brain 1.6.0 → 2.0.0

package/src/db/_reminders.py

@@ -7,7 +7,7 @@ from db._fts import fts_upsert
 # ── Reminders ──────────────────────────────────────────────────────
 
 def create_reminder(id: str, description: str, date: str = None,
-                    status: str = 'PENDIENTE', category: str = 'general') -> dict:
+                    status: str = 'PENDING', category: str = 'general') -> dict:
     """Create a new reminder."""
     conn = get_db()
     now = now_epoch()
@@ -46,7 +46,7 @@ def update_reminder(id: str, **kwargs) -> dict:
 def complete_reminder(id: str) -> dict:
     """Mark a reminder as completed with today's date."""
     today = datetime.date.today().isoformat()
-    return update_reminder(id, status="COMPLETADO")
+    return update_reminder(id, status="COMPLETED")
 
 
 def delete_reminder(id: str) -> bool:
@@ -64,19 +64,19 @@ def get_reminders(filter_type: str = 'all') -> list[dict]:
     today = datetime.date.today().isoformat()
     if filter_type == 'completed':
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status LIKE 'COMPLETADO%' ORDER BY updated_at DESC"
+            "SELECT * FROM reminders WHERE status LIKE 'COMPLETED%' ORDER BY updated_at DESC"
         ).fetchall()
     elif filter_type == 'due':
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETADO%' "
-            "AND status != 'ELIMINADO' AND date IS NOT NULL AND date <= ? "
+            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETED%' "
+            "AND status != 'DELETED' AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
-            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETADO%' "
-            "AND status != 'ELIMINADO' ORDER BY date ASC NULLS LAST"
+            "SELECT * FROM reminders WHERE status NOT LIKE 'COMPLETED%' "
+            "AND status != 'DELETED' ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
 
@@ -88,18 +88,68 @@ def get_reminder(id: str) -> dict | None:
     return dict(row) if row else None
 
 
+def find_similar_followups(description: str, threshold: float = 0.3) -> list[dict]:
+    """Find open followups similar to a description using keyword overlap.
+
+    Uses asymmetric scoring: what fraction of the SMALLER token set overlaps
+    with the larger. This handles different-length texts better than Jaccard.
+
+    Returns matches sorted by similarity score (highest first).
+    threshold: minimum overlap ratio (0.0-1.0) to consider a match.
+    """
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
+        "AND status != 'DELETED'"
+    ).fetchall()
+
+    def tokenize(text: str) -> set:
+        return {w.lower() for w in text.split() if len(w) > 3}
+
+    query_tokens = tokenize(description)
+    if not query_tokens:
+        return []
+
+    matches = []
+    for row in rows:
+        existing_tokens = tokenize(f"{row['id']} {row['description']} {row['verification'] or ''}")
+        if not existing_tokens:
+            continue
+        intersection = query_tokens & existing_tokens
+        if not intersection:
+            continue
+        smaller = min(len(query_tokens), len(existing_tokens))
+        score = len(intersection) / smaller if smaller else 0
+        if score >= threshold:
+            matches.append({**dict(row), "_similarity": round(score, 2)})
+
+    matches.sort(key=lambda x: x["_similarity"], reverse=True)
+    return matches[:5]
+
+
 # ── Followups ──────────────────────────────────────────────────────
 
 def create_followup(id: str, description: str, date: str = None,
-                    verification: str = '', status: str = 'PENDIENTE',
+                    verification: str = '', status: str = 'PENDING',
                     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) "
@@ -111,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:
@@ -190,7 +243,7 @@ def complete_followup(id: str, result: str = '') -> dict:
         return {"error": f"Followup {id} not found"}
 
     today = datetime.date.today().isoformat()
-    kwargs = {"status": "COMPLETADO"}
+    kwargs = {"status": "COMPLETED"}
     if result:
         existing = row["verification"] or ''
         kwargs["verification"] = f"{existing}\n{result}".strip() if existing else result
@@ -206,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"],
@@ -215,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
 
 
@@ -234,19 +308,19 @@ def get_followups(filter_type: str = 'all') -> list[dict]:
     today = datetime.date.today().isoformat()
     if filter_type == 'completed':
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status LIKE 'COMPLETADO%' ORDER BY updated_at DESC"
+            "SELECT * FROM followups WHERE status LIKE 'COMPLETED%' ORDER BY updated_at DESC"
         ).fetchall()
     elif filter_type == 'due':
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETADO%' "
-            "AND status != 'ELIMINADO' AND date IS NOT NULL AND date <= ? "
+            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
+            "AND status != 'DELETED' AND date IS NOT NULL AND date <= ? "
             "ORDER BY date ASC",
             (today,)
         ).fetchall()
     else:  # 'all' — active only
         rows = conn.execute(
-            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETADO%' "
-            "AND status != 'ELIMINADO' ORDER BY date ASC NULLS LAST"
+            "SELECT * FROM followups WHERE status NOT LIKE 'COMPLETED%' "
+            "AND status != 'DELETED' ORDER BY date ASC NULLS LAST"
         ).fetchall()
     return [dict(r) for r in rows]
 

package/src/db/_schema.py

@@ -256,6 +256,45 @@ def _m13_claude_session_id(conn):
     conn.commit()
 
 
+def _m14_learnings_priority_weight(conn):
+    """Add priority, weight, and guard usage tracking to learnings + followup priority."""
+    _migrate_add_column(conn, "learnings", "priority", "TEXT DEFAULT 'medium'")
+    _migrate_add_column(conn, "learnings", "weight", "REAL DEFAULT 0.5")
+    _migrate_add_column(conn, "learnings", "guard_hits", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "learnings", "last_guard_hit_at", "REAL")
+    _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),
@@ -271,6 +310,8 @@ MIGRATIONS = [
     (11, "artifact_registry", _m11_artifact_registry),
     (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

package/src/hooks/session-start.sh

@@ -48,7 +48,7 @@ from datetime import date
 today_str = '$TODAY'
 weekday = '$WEEKDAY'
 nexo_home = os.environ.get('NEXO_HOME', os.path.expanduser('~/.nexo'))
-db_path = os.path.join(nexo_home, 'nexo.db')
+db_path = os.path.join(nexo_home, 'data', 'nexo.db')
 
 lines = []
 lines.append(f'## Date: {today_str} ({weekday})')
@@ -212,7 +212,11 @@ except Exception as e:
 fi
 
 # ─── Cortex Report: what happened while user was away ───
-CORTEX_BRIEFING="$NEXO_HOME/cortex/last-briefing.json"
+# Check brain/ (canonical) first, fall back to cortex/ (legacy)
+CORTEX_BRIEFING="$NEXO_HOME/brain/last-briefing.json"
+if [ ! -f "$CORTEX_BRIEFING" ] && [ -f "$NEXO_HOME/cortex/last-briefing.json" ]; then
+    CORTEX_BRIEFING="$NEXO_HOME/cortex/last-briefing.json"
+fi
 if [ -f "$CORTEX_BRIEFING" ]; then
     CORTEX_SECTION=$(python3 -c "
 import json

package/src/hooks/session-stop.sh

@@ -25,7 +25,8 @@ TOOL_LOG="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
 python3 -c "
 import sys, json, os
 nexo_home = os.environ.get('NEXO_HOME', os.path.expanduser('~/.nexo'))
-sys.path.insert(0, os.path.join(nexo_home, 'nexo-mcp'))
+nexo_code = os.environ.get('NEXO_CODE', nexo_home)
+sys.path.insert(0, nexo_code)
 os.environ['NEXO_SKIP_FS_INDEX'] = '1'
 from db import init_db, get_db, get_active_sessions, upsert_diary_draft, get_diary_draft
 init_db()

package/src/kg_populate.py

@@ -13,7 +13,10 @@ from db import get_db
 
 def _cognitive_db():
     """Direct cognitive.db connection (for somatic_markers)."""
-    path = os.path.join(os.path.dirname(__file__), "cognitive.db")
+    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)
+    path = os.path.join(data_dir, "cognitive.db")
     conn = sqlite3.connect(path)
     conn.row_factory = sqlite3.Row
     return conn

package/src/migrate_embeddings.py

@@ -15,7 +15,10 @@ import sys
 import time
 import numpy as np
 
-DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cognitive.db")
+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.path.join(_data_dir, "cognitive.db")
 BACKUP_PATH = DB_PATH + ".bak-384dims-pre-upgrade"
 
 MODELS = {