nexo-brain 2.3.0 → 2.3.1

package/src/hooks/pre-compact 2.sh

@@ -1,151 +0,0 @@
-#!/bin/bash
-# NEXO PreCompact Hook — Save checkpoint + inject preservation instructions
-# This runs BEFORE Claude Code compacts. It:
-# 1. Enriches the session checkpoint in SQLite with latest diary draft data
-# 2. Injects a systemMessage telling the operator to save any WIP via MCP tools
-set -uo pipefail
-
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-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
-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
-    " 2>/dev/null || echo "")
-
-    if [ -n "$LATEST_SID" ]; 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
-    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.\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 2.sh

@@ -1,268 +0,0 @@
-#!/bin/bash
-# NEXO SessionStart hook — generates a comprehensive briefing
-# Reads SQLite directly for reminders, followups, active sessions.
-# Caches output for 1 hour to avoid regenerating on rapid successive sessions.
-set -uo pipefail
-
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-BRIEFING_FILE="$NEXO_HOME/coordination/session-briefing.txt"
-MAX_AGE_SECONDS=3600  # 1 hour cache
-
-mkdir -p "$NEXO_HOME/coordination" "$NEXO_HOME/operations"
-
-# Write session start timestamp for session-scoped tool counting
-date +%s > "$NEXO_HOME/operations/.session-start-ts"
-
-# Clean up post-mortem flag from previous session
-rm -f "$NEXO_HOME/operations/.postmortem-complete" 2>/dev/null
-
-# Capture Claude Code session_id for inter-terminal inbox hook
-HOOK_INPUT=$(cat || true)
-CLAUDE_SID=""
-if [ -n "$HOOK_INPUT" ]; then
-    CLAUDE_SID=$(echo "$HOOK_INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null || true)
-fi
-if [ -n "$CLAUDE_SID" ]; then
-    echo "$CLAUDE_SID" > "/tmp/nexo-claude-sid-${CLAUDE_SID}"
-    # Also write to a predictable location for the startup prompt
-    echo "$CLAUDE_SID" > "$NEXO_HOME/coordination/.claude-session-id"
-fi
-
-# If briefing exists and is less than 1 hour old, skip regeneration
-if [ -f "$BRIEFING_FILE" ]; then
-    if [ "$(uname)" = "Darwin" ]; then
-        file_age=$(( $(date +%s) - $(stat -f %m "$BRIEFING_FILE") ))
-    else
-        file_age=$(( $(date +%s) - $(stat -c %Y "$BRIEFING_FILE") ))
-    fi
-    if [ "$file_age" -lt "$MAX_AGE_SECONDS" ]; then
-        exit 0
-    fi
-fi
-
-TODAY=$(date +%Y-%m-%d)
-WEEKDAY=$(date +%A)
-
-# Generate briefing from SQLite
-python3 -c "
-import json, os, sys
-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, 'data', 'nexo.db')
-
-lines = []
-lines.append(f'## Date: {today_str} ({weekday})')
-lines.append('')
-
-# Read from SQLite
-reminders_rows = []
-followups_rows = []
-sessions = []
-sqlite_ok = True
-
-try:
-    import sqlite3
-    if not os.path.exists(db_path):
-        sqlite_ok = False
-    else:
-        db = sqlite3.connect(db_path, timeout=10)
-        db.execute('PRAGMA journal_mode=WAL')
-        db.execute('PRAGMA busy_timeout=10000')
-        db.row_factory = sqlite3.Row
-
-        try:
-            reminders_rows = [dict(r) for r in db.execute(
-                'SELECT id, date, description, status, category FROM reminders '
-                'WHERE status NOT LIKE \"%COMPLET%\" AND status NOT LIKE \"%DELET%\" '
-                'AND status NOT LIKE \"%COMPLETED%\" AND status NOT LIKE \"%DELETED%\"'
-            ).fetchall()]
-        except Exception:
-            pass
-
-        try:
-            followups_rows = [dict(r) for r in db.execute(
-                'SELECT id, date, description, status FROM followups '
-                'WHERE status NOT LIKE \"%COMPLET%\" AND status NOT LIKE \"%COMPLETED%\"'
-            ).fetchall()]
-        except Exception:
-            pass
-
-        try:
-            rows = db.execute(
-                'SELECT sid, task, started FROM sessions '
-                'WHERE completed=0 AND (strftime(\"%s\",\"now\") - last_update) < 900'
-            ).fetchall()
-            sessions = [{'sid': r['sid'], 'task': r['task'], 'started': r['started'][:16]} for r in rows]
-        except Exception:
-            pass
-
-        db.close()
-except Exception:
-    sqlite_ok = False
-
-if not sqlite_ok:
-    lines.append('Database not initialized yet. Run nexo_startup to begin.')
-    lines.append('')
-    print('\n'.join(lines))
-    sys.exit(0)
-
-# Overdue reminders
-lines.append('## Overdue Reminders')
-found = False
-for r in reminders_rows:
-    rdate = r.get('date', '')
-    if rdate and rdate[:10] < today_str:
-        try:
-            delta = (date.fromisoformat(today_str) - date.fromisoformat(rdate[:10])).days
-        except:
-            delta = '?'
-        desc = (r.get('description', '') or '')[:120]
-        lines.append(f'- [{r[\"id\"]}] {rdate} {desc} -- {delta} day(s) overdue')
-        found = True
-if not found:
-    lines.append('NONE')
-lines.append('')
-
-# Today's reminders
-lines.append('## Reminders Due Today')
-found = False
-for r in reminders_rows:
-    rdate = r.get('date', '')
-    if rdate and rdate[:10] == today_str:
-        desc = (r.get('description', '') or '')[:120]
-        lines.append(f'- [{r[\"id\"]}] {desc}')
-        found = True
-if not found:
-    lines.append('NONE')
-lines.append('')
-
-# Pending followups (due today or overdue)
-lines.append('## Followups Due Today or Overdue')
-found = False
-for r in followups_rows:
-    fdate = r.get('date', '')
-    if fdate and fdate[:10] <= today_str:
-        desc = (r.get('description', '') or '')[:100]
-        lines.append(f'- [{r[\"id\"]}] {fdate} {desc}')
-        found = True
-if not found:
-    lines.append('NONE')
-lines.append('')
-
-# Active sessions
-lines.append('## Active Sessions')
-if sessions:
-    for s in sessions:
-        lines.append(f'- [{s[\"sid\"]}] {s[\"task\"]} (since {s[\"started\"]})')
-else:
-    lines.append('NONE')
-lines.append('')
-
-# Last self-audit
-audit_file = os.path.join(nexo_home, 'logs', 'self-audit-summary.json')
-if os.path.exists(audit_file):
-    try:
-        audit = json.load(open(audit_file))
-        lines.append('## Last Self-Audit')
-        lines.append(json.dumps(audit, indent=2)[:500])
-        lines.append('')
-    except Exception:
-        pass
-
-print('\n'.join(lines))
-" > "$BRIEFING_FILE" 2>/dev/null
-
-# If generation failed, write minimal briefing
-if [ ! -s "$BRIEFING_FILE" ]; then
-    echo "## Briefing unavailable — generation error. Use nexo_reminders MCP for fresh data." > "$BRIEFING_FILE"
-fi
-
-# ─── Semantic Context: recent work sessions ───
-# Append recent session summaries for immediate context
-CLAUDE_MEM_DB="$NEXO_HOME/claude-mem.db"
-
-if [ -f "$CLAUDE_MEM_DB" ]; then
-    RECENT_SESSIONS=$(python3 -c "
-import sqlite3, sys
-try:
-    db = sqlite3.connect('$CLAUDE_MEM_DB')
-    rows = db.execute('''
-        SELECT created_at, request, learned, completed
-        FROM session_summaries
-        ORDER BY id DESC LIMIT 5
-    ''').fetchall()
-    db.close()
-    if rows:
-        print()
-        print('## Last 5 Work Sessions')
-        for r in rows:
-            date = r[0][:16] if r[0] else '?'
-            req = (r[1] or '')[:120]
-            learned = (r[2] or '')[:100]
-            print(f'- [{date}] {req}')
-            if learned:
-                print(f'  -> {learned}')
-except Exception as e:
-    pass
-" 2>/dev/null)
-
-    if [ -n "$RECENT_SESSIONS" ]; then
-        echo "$RECENT_SESSIONS" >> "$BRIEFING_FILE"
-    fi
-fi
-
-# ─── Cortex Report: what happened while user was away ───
-# 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
-try:
-    data = json.load(open('$CORTEX_BRIEFING'))
-    ts = data.get('timestamp', '?')
-    actions = data.get('actions_taken', [])
-    signals = data.get('signals_active', [])
-    recommendations = data.get('recommendations', [])
-    pending_q = data.get('pending_questions_unanswered', [])
-    dmn_summary = data.get('dmn_summary', '')
-
-    print()
-    print('## Cortex Report (last update: ' + str(ts)[:16] + ')')
-    if actions:
-        print('### Actions Executed')
-        for a in actions[-10:]:
-            if isinstance(a, dict):
-                print(f'- [{a.get(\"type\",\"?\")}] {a.get(\"detail\",\"\")}')
-            else:
-                print(f'- {a}')
-    if signals:
-        print('### Active Signals')
-        for s in signals[:5]:
-            print(f'- {s}')
-    if recommendations:
-        print('### Recommendations')
-        for r in recommendations[:3]:
-            print(f'- {r}')
-    if pending_q:
-        print(f'### Unanswered Questions: {len(pending_q)}')
-        for q in pending_q[:3]:
-            if isinstance(q, dict):
-                print(f'- {q.get(\"question\",\"?\")}')
-            else:
-                print(f'- {q}')
-    if dmn_summary:
-        print(f'### Last DMN: {str(dmn_summary)[:200]}')
-except Exception as e:
-    print(f'## Cortex Report: error reading briefing ({e})')
-" 2>/dev/null)
-
-    if [ -n "$CORTEX_SECTION" ]; then
-        echo "$CORTEX_SECTION" >> "$BRIEFING_FILE"
-    fi
-fi

package/src/hooks/session-stop 2.sh

@@ -1,140 +0,0 @@
-#!/bin/bash
-# NEXO Memory Stop Hook (v7 — BLOCKING post-mortem with trivial session detection)
-#
-# v5 bug: used "approve" + systemMessage — AI never processed post-mortem.
-# v6 fix: uses "block" — but blocked ALL sessions including trivial ones.
-# v7 fix: detects trivial sessions (<5 tool calls) and approves immediately.
-#         Non-trivial sessions get blocked until post-mortem is done.
-#
-# Flow:
-#   Trivial session (quick question, <5 tool calls):
-#     → APPROVE immediately, no post-mortem needed
-#
-#   Non-trivial session:
-#     1. User closes → hook checks flag → not found → BLOCK
-#     2. AI executes post-mortem → creates flag
-#     3. User closes again → hook sees flag → APPROVE
-set -uo pipefail
-
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-FLAG_FILE="$NEXO_HOME/operations/.postmortem-complete"
-TODAY=$(date +%Y-%m-%d)
-TOOL_LOG="$NEXO_HOME/operations/tool-logs/${TODAY}.jsonl"
-
-# 0. Refresh diary draft with latest changes/decisions (best-effort)
-python3 -c "
-import sys, json, os
-nexo_home = os.environ.get('NEXO_HOME', os.path.expanduser('~/.nexo'))
-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()
-conn = get_db()
-sessions = get_active_sessions()
-for s in sessions:
-    sid = s['sid']
-    draft = get_diary_draft(sid)
-    if not draft:
-        continue
-    change_ids = [r[0] for r in conn.execute('SELECT id FROM change_log WHERE session_id = ?', (sid,)).fetchall()]
-    decision_ids = [r[0] for r in conn.execute('SELECT id FROM decisions WHERE session_id = ?', (sid,)).fetchall()]
-    upsert_diary_draft(
-        sid=sid,
-        tasks_seen=draft['tasks_seen'],
-        change_ids=json.dumps(change_ids),
-        decision_ids=json.dumps(decision_ids),
-        last_context_hint=draft['last_context_hint'],
-        heartbeat_count=draft['heartbeat_count'],
-        summary_draft=draft['summary_draft'],
-    )
-" 2>/dev/null || true
-
-# 1. Detect trivial session — count meaningful tool calls from THIS session only
-# Uses .session-start-ts written by SessionStart hook
-# A session with <5 tool calls (excluding Read/Grep/Glob/Bash) is trivial
-SESSION_START_TS="$NEXO_HOME/operations/.session-start-ts"
-
-# 0.5. Detect non-interactive (claude -p) sessions — skip post-mortem entirely
-#      SessionStart hook writes .session-start-ts. If missing or stale (>30 min),
-#      this is likely a -p script session — approve immediately.
-#      Also skip if NEXO_HEADLESS=1 is set (explicit headless mode for scripts).
-if [ "${NEXO_HEADLESS:-}" = "1" ] || [ ! -f "$SESSION_START_TS" ] || [ "$(($(date +%s) - $(cat "$SESSION_START_TS" 2>/dev/null || echo 0)))" -gt 1800 ]; then
-    cat << 'HOOKEOF'
-{
-  "decision": "approve"
-}
-HOOKEOF
-    exit 0
-fi
-SESSION_START=0
-if [ -f "$SESSION_START_TS" ]; then
-    SESSION_START=$(cat "$SESSION_START_TS" 2>/dev/null || echo "0")
-fi
-
-TOOL_COUNT=0
-if [ -f "$TOOL_LOG" ]; then
-    TOOL_COUNT=$(python3 -c "
-import json, sys, os
-session_start = float(os.environ.get('SESSION_START', '0'))
-count = 0
-for line in open('$TOOL_LOG'):
-    try:
-        d = json.loads(line)
-        # Only count tools from THIS session (after session-start-ts)
-        ts = d.get('timestamp', '')
-        if ts and session_start > 0:
-            from datetime import datetime
-            try:
-                entry_ts = datetime.fromisoformat(ts.replace('Z', '+00:00')).timestamp()
-                if entry_ts < session_start:
-                    continue
-            except:
-                pass
-        t = d.get('tool_name', '')
-        if t and t not in ('Read', 'Grep', 'Glob', 'Bash', 'ToolSearch'):
-            count += 1
-    except:
-        pass
-print(count)
-" 2>/dev/null || echo "0")
-fi
-
-# Trivial session → approve immediately, no buffer writing, skip post-mortem
-if [ "$TOOL_COUNT" -lt 5 ]; then
-    cat << 'HOOKEOF'
-{
-  "decision": "approve"
-}
-HOOKEOF
-    exit 0
-fi
-
-# 2. Non-trivial session — check if post-mortem was already completed
-#    Flag has NO TTL — it persists until SessionStart cleans it up next session.
-POSTMORTEM_DONE=false
-if [ -f "$FLAG_FILE" ]; then
-    POSTMORTEM_DONE=true
-fi
-
-if [ "$POSTMORTEM_DONE" = true ]; then
-    # Post-mortem was done — allow session to close
-    # NOTE: do NOT delete flag here — SessionStart cleans it up next session
-    cat << 'HOOKEOF'
-{
-  "decision": "approve"
-}
-HOOKEOF
-else
-    # Post-mortem NOT done — BLOCK session close and inject instructions
-    cat << 'HOOKEOF'
-{
-  "decision": "block",
-  "reason": "STOP HOOK — MANDATORY POST-MORTEM before ending (do NOT ask permission, do NOT skip):\n\n## 1. SELF-CRITIQUE (MANDATORY — write to session diary)\nAnswer these questions in the self_critique field of nexo_session_diary_write:\n- Did the user have to ask me for something I should have detected or done on my own?\n- Did I wait for the user to tell me something I could have verified proactively?\n- Are there systems/states I can check next session without being asked?\n- Did I repeat an error that already had a registered learning?\n- What would I do differently if I repeated this session?\nIf any answer is YES — write the specific rule that would prevent repetition.\nIf the session was flawless, write 'No self-critique — clean session.'\n\n## 2. SESSION BUFFER\nIf the session was NOT trivial, append ONE JSON line to $NEXO_HOME/brain/session_buffer.jsonl:\n{\"ts\":\"YYYY-MM-DDTHH:MM:SS\",\"tasks\":[...],\"decisions\":[...],\"user_patterns\":[...],\"files_modified\":[...],\"errors_resolved\":[...],\"self_critique\":\"short summary\",\"mood\":\"focused|impatient|exploratory|frustrated|satisfied|neutral\",\"source\":\"claude\"}\n\n## 3. FOLLOWUPS\nIf there were deploys/cron changes/fixes — nexo_followup_create with verification date.\n\n## 4. PROACTIVE SEEDS\nWhat can I leave prepared so the next session starts doing useful work without the user asking?\n\n## 5. MARK COMPLETE\nWhen ALL of the above is done, run:\nbash -c 'mkdir -p $NEXO_HOME/operations && date +%s > $NEXO_HOME/operations/.postmortem-complete'\nThe user will close again and the hook will approve.\n\nIMPORTANT: Do NOT say goodbye, do NOT say goodnight or any farewell. Just execute the steps and mark complete."
-}
-HOOKEOF
-fi
-
-# 3. Session buffer fallback REMOVED (v8)
-# The old hook-fallback was 86% noise. Session diary (written by Claude during
-# post-mortem) is the only source of truth now. No more buffer writing.