nexo-brain 2.0.0 → 2.2.0

package/src/scripts/nexo-postmortem-consolidator.py

@@ -113,7 +113,7 @@ def consolidate_with_cli(data: dict) -> bool:
 
     diaries_with_critique = [
         d for d in data["diaries"]
-        if d.get("self_critique") and not (d["self_critique"] or "").strip().lower().startswith("no self-critique")
+        if d.get("self_critique") and not str(d["self_critique"]).strip().lower().startswith("no self-critique")
     ]
 
     if not diaries_with_critique:
@@ -125,8 +125,10 @@ def consolidate_with_cli(data: dict) -> bool:
     if len(diaries_json) > 12000:
         diaries_json = diaries_json[:12000] + "\n... (truncated)"
 
-    prompt = f"""You are NEXO's nightly consolidator. Your job is to review the self-critiques
-from today and decide which deserve to become permanent rules (feedback_postmortem_*.md).
+    prompt = f"""FIRST: Call nexo_startup(task='nightly postmortem consolidation') to register this session.
+
+You are NEXO's nightly consolidator. Your job is to review the self-critiques
+from today and decide which deserve to become permanent rules. Use nexo_learning_add for permanent rules and nexo_followup_create for action items.
 
 DATE: {data['date']}
 SESSIONS TODAY: {len(data['diaries'])} total, {len(diaries_with_critique)} with self-critique
@@ -185,30 +187,17 @@ INSTRUCTIONS:
 Execute without asking."""
 
     log(f"Stage 2: Invoking Claude CLI (opus) with {len(diaries_with_critique)} critiques...")
-
-    # Verify Claude CLI is authenticated before calling
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            log("Stage 2: Claude CLI not available or not authenticated. Skipping Stage 2.")
-            return False
-    except Exception:
-        log("Stage 2: Claude CLI check failed. Skipping Stage 2.")
-        return False
-
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
             [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=300, env=env
+             "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
 
         if result.returncode != 0:

package/src/scripts/nexo-pre-commit 2.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env /Library/Frameworks/Python.framework/Versions/3.12/bin/python3
+"""
+NEXO Pre-Commit Validator — Dynamic version
+Queries nexo.db learnings to surface relevant warnings/blockers before commit.
+Runs standalone (no MCP dependency, just sqlite3).
+"""
+import os
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+
+
+def get_staged_files():
+    """Get list of staged files."""
+    result = subprocess.run(
+        ['git', 'diff', '--cached', '--name-only'],
+        capture_output=True, text=True
+    )
+    return [f for f in result.stdout.strip().split('\n') if f]
+
+
+def check_file(filepath, conn):
+    """Dynamic checks from learnings DB."""
+    errors, warnings = [], []
+
+    filename = Path(filepath).name
+    parent_dir = Path(filepath).parent.name
+
+    # 1. Find learnings mentioning this file or directory
+    file_learnings = conn.execute(
+        "SELECT id, title, content FROM learnings WHERE INSTR(content, ?) > 0 OR INSTR(content, ?) > 0",
+        (filename, parent_dir)
+    ).fetchall()
+
+    # 2. Check repetition count for each matching learning
+    for row in file_learnings:
+        lid, title = row[0], row[1]
+        rep_count = conn.execute(
+            "SELECT COUNT(*) FROM error_repetitions WHERE original_learning_id = ?",
+            (lid,)
+        ).fetchone()[0]
+
+        if rep_count >= 5:
+            errors.append(f"BLOCKED #{lid} ({rep_count}x repeated): {title[:80]}")
+        elif rep_count >= 3:
+            warnings.append(f"WARNING #{lid} ({rep_count}x repeated): {title[:80]}")
+
+    # 3. Universal rules (SIEMPRE/NUNCA/ANTES) matching this file
+    universal = conn.execute(
+        "SELECT id, title, content FROM learnings WHERE "
+        "(content LIKE '%SIEMPRE%' OR content LIKE '%NUNCA%' OR content LIKE '%ANTES%') "
+        "AND (INSTR(content, ?) > 0 OR INSTR(content, ?) > 0)",
+        (filename, parent_dir)
+    ).fetchall()
+
+    for row in universal:
+        lid, title = row[0], row[1]
+        # Don't duplicate if already found above
+        if not any(f"#{lid}" in e for e in errors + warnings):
+            warnings.append(f"RULE #{lid}: {title[:80]}")
+
+    return errors, warnings
+
+
+def main():
+    """Run pre-commit validation."""
+    staged = get_staged_files()
+    if not staged:
+        print("No staged files to check")
+        return 0
+
+    if not NEXO_DB.exists():
+        print("nexo.db not found — skipping dynamic checks")
+        return 0
+
+    conn = sqlite3.connect(str(NEXO_DB), timeout=5)
+
+    all_errors = {}
+    all_warnings = {}
+
+    for filepath in staged:
+        errors, warnings = check_file(filepath, conn)
+        if errors:
+            all_errors[filepath] = errors
+        if warnings:
+            all_warnings[filepath] = warnings
+
+    conn.close()
+
+    # Print warnings (non-blocking)
+    if all_warnings:
+        print("\nWARNINGS:")
+        for filepath, warns in all_warnings.items():
+            print(f"\n  {filepath}:")
+            for w in warns:
+                print(f"    - {w}")
+
+    # Print errors (blocking)
+    if all_errors:
+        print("\nBLOCKED — Fix these before committing:\n")
+        for filepath, errs in all_errors.items():
+            print(f"  {filepath}:")
+            for e in errs:
+                print(f"    - {e}")
+        print()
+        return 1
+
+    if all_warnings:
+        print("\nPre-commit passed with warnings\n")
+    else:
+        print("Pre-commit validation passed")
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/src/scripts/nexo-prevent-sleep 2.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# NEXO Prevent Sleep — keeps the machine awake so nocturnal processes run.
+#
+# macOS: uses caffeinate -s -i (prevent system + idle sleep)
+# Linux: uses systemd-inhibit or caffeine if available, otherwise no-op
+#
+# Run as LaunchAgent (KeepAlive) or systemd service.
+
+case "$(uname -s)" in
+    Darwin)
+        exec caffeinate -s -i -w $$
+        ;;
+    Linux)
+        if command -v systemd-inhibit &>/dev/null; then
+            exec systemd-inhibit --what=idle:sleep --who=nexo --why="NEXO nocturnal processes" sleep infinity
+        elif command -v caffeine &>/dev/null; then
+            exec caffeine
+        else
+            echo "[NEXO] No sleep prevention tool found. Install systemd-inhibit or caffeine."
+            echo "[NEXO] Nocturnal processes may not run if the system sleeps."
+            # Keep running so launchd/systemd doesn't restart loop
+            exec sleep infinity
+        fi
+        ;;
+    *)
+        echo "[NEXO] Unsupported platform: $(uname -s)"
+        exit 1
+        ;;
+esac

package/src/scripts/nexo-proactive-dashboard 2.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+NEXO Proactive Dashboard — Surfaces issues and opportunities without the user asking.
+
+Scans: overdue followups, forgotten reminders, unresolved learnings,
+inactive systems, user patterns, and more.
+
+Usage:
+    python3 nexo-proactive-dashboard.py           # Full scan, text output
+    python3 nexo-proactive-dashboard.py --json     # JSON output for programmatic use
+    python3 nexo-proactive-dashboard.py --brief    # One-liner alerts only
+"""
+
+import json
+import os
+import sqlite3
+import subprocess
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+
+
+def get_db():
+    conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def check_overdue_followups() -> list[dict]:
+    """Find followups that are overdue and not completed."""
+    conn = get_db()
+    now_epoch = datetime.now().timestamp()
+    rows = conn.execute("""
+        SELECT id, description, date, created_at, reasoning
+        FROM followups
+        WHERE status NOT LIKE 'COMPLETED%'
+        AND status NOT IN ('DELETED','archived','blocked','waiting')
+        AND date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        due_str = r["date"]
+        try:
+            due = datetime.fromisoformat(due_str) if due_str else None
+            if due and due < datetime.now():
+                days_overdue = (datetime.now() - due).days
+                alerts.append({
+                    "type": "overdue_followup",
+                    "severity": "high" if days_overdue > 3 else "medium",
+                    "title": f"Followup overdue by {days_overdue}d: {r['description'][:80]}",
+                    "id": r["id"],
+                    "days_overdue": days_overdue,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_overdue_reminders() -> list[dict]:
+    """Find reminders that are overdue."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, description, date, status
+        FROM reminders
+        WHERE status NOT IN ('COMPLETED', 'CANCELLED')
+        AND date IS NOT NULL AND date != ''
+        ORDER BY date ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        due_str = r["date"]
+        try:
+            due = datetime.fromisoformat(due_str) if due_str else None
+            if due and due < datetime.now():
+                days_overdue = (datetime.now() - due).days
+                alerts.append({
+                    "type": "overdue_reminder",
+                    "severity": "high" if days_overdue > 7 else "medium",
+                    "title": f"Reminder overdue by {days_overdue}d: {r['description'][:80]}",
+                    "id": r["id"],
+                    "days_overdue": days_overdue,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_stale_ideas() -> list[dict]:
+    """Find reminders/ideas without due dates that have been sitting for too long."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, description, created_at
+        FROM reminders
+        WHERE status NOT IN ('COMPLETED', 'CANCELLED')
+        AND (date IS NULL OR date = '')
+        ORDER BY created_at ASC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    stale_count = 0
+    for r in rows:
+        try:
+            # created_at is epoch float
+            created = datetime.fromtimestamp(r["created_at"])
+            age_days = (datetime.now() - created).days
+        except (ValueError, TypeError, OSError):
+            age_days = 0
+        if age_days > 14:
+            stale_count += 1
+
+    if stale_count > 10:
+        alerts.append({
+            "type": "stale_ideas",
+            "severity": "low",
+            "title": f"{stale_count} ideas/reminders without date have been sitting for >14 days. Review or archive.",
+            "count": stale_count,
+        })
+    return alerts
+
+
+def check_session_gaps() -> list[dict]:
+    """Detect if NEXO hasn't been active for unusual periods."""
+    conn = get_db()
+    row = conn.execute("""
+        SELECT MAX(created_at) as last_diary FROM session_diary
+    """).fetchone()
+    conn.close()
+    alerts = []
+    if row and row["last_diary"]:
+        try:
+            last = datetime.fromisoformat(row["last_diary"])
+            gap_hours = (datetime.now() - last).total_seconds() / 3600
+            if gap_hours > 48:
+                alerts.append({
+                    "type": "session_gap",
+                    "severity": "low",
+                    "title": f"No sessions recorded in {gap_hours:.0f}h ({gap_hours/24:.1f} days)",
+                    "gap_hours": gap_hours,
+                })
+        except (ValueError, TypeError):
+            pass
+    return alerts
+
+
+def check_evolution_status() -> list[dict]:
+    """Check if evolution system is healthy."""
+    alerts = []
+    obj_file = NEXO_HOME / "brain" / "evolution-objective.json"
+    if obj_file.exists():
+        obj = json.loads(obj_file.read_text())
+        if not obj.get("evolution_enabled", True):
+            alerts.append({
+                "type": "evolution_disabled",
+                "severity": "high",
+                "title": f"Evolution DISABLED: {obj.get('disabled_reason', 'unknown')}",
+            })
+        if obj.get("consecutive_failures", 0) > 0:
+            alerts.append({
+                "type": "evolution_failures",
+                "severity": "medium",
+                "title": f"Evolution: {obj['consecutive_failures']} consecutive failures",
+            })
+
+        # Check dimension regression
+        for dim, data in obj.get("dimensions", {}).items():
+            current = data.get("current", 0)
+            if current < 30:
+                alerts.append({
+                    "type": "dimension_low",
+                    "severity": "medium",
+                    "title": f"Dimension '{dim}' baja: {current}%",
+                    "dimension": dim,
+                    "score": current,
+                })
+    return alerts
+
+
+def check_pending_proposals() -> list[dict]:
+    """Check for evolution proposals awaiting the user's review."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT id, dimension, proposal, created_at
+        FROM evolution_log
+        WHERE status = 'proposed' AND classification = 'propose'
+        ORDER BY created_at DESC
+    """).fetchall()
+    conn.close()
+    if rows:
+        return [{
+            "type": "pending_proposals",
+            "severity": "low",
+            "title": f"{len(rows)} evolution proposals pending review",
+            "count": len(rows),
+            "proposals": [{"id": r["id"], "dim": r["dimension"], "text": r["proposal"][:80]} for r in rows],
+        }]
+    return []
+
+
+def check_recurring_errors() -> list[dict]:
+    """Detect learnings that keep appearing (same issue reported multiple times)."""
+    conn = get_db()
+    rows = conn.execute("""
+        SELECT category, COUNT(*) as cnt
+        FROM learnings
+        WHERE created_at > datetime('now', '-7 days')
+        GROUP BY category
+        HAVING cnt >= 5
+        ORDER BY cnt DESC
+    """).fetchall()
+    conn.close()
+    alerts = []
+    for r in rows:
+        alerts.append({
+            "type": "recurring_errors",
+            "severity": "medium",
+            "title": f"Category '{r['category']}' has {r['cnt']} learnings this week — possible systemic issue",
+            "category": r["category"],
+            "count": r["cnt"],
+        })
+    return alerts
+
+
+def check_cron_health() -> list[dict]:
+    """Check if critical cron jobs are running."""
+    alerts = []
+
+    # Check backup cron
+    backup_dir = NEXO_HOME / "backups"
+    if backup_dir.exists():
+        backups = sorted(backup_dir.glob("nexo-*.db"), key=lambda p: p.stat().st_mtime, reverse=True)
+        if backups:
+            last_backup_age = (datetime.now().timestamp() - backups[0].stat().st_mtime) / 3600
+            if last_backup_age > 4:
+                alerts.append({
+                    "type": "backup_stale",
+                    "severity": "high",
+                    "title": f"Last nexo.db backup {last_backup_age:.1f}h (should be hourly)",
+                })
+
+    # Check immune system
+    immune_status = NEXO_HOME / "coordination" / "immune-status.json"
+    if immune_status.exists():
+        try:
+            status = json.loads(immune_status.read_text())
+            if status.get("status") == "degraded":
+                alerts.append({
+                    "type": "immune_degraded",
+                    "severity": "high",
+                    "title": f"Immune system degraded: {status.get('reason', '?')}",
+                })
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    return alerts
+
+
+def run_all_checks() -> list[dict]:
+    """Run all proactive checks and return sorted alerts."""
+    all_alerts = []
+    checks = [
+        check_overdue_followups,
+        check_overdue_reminders,
+        check_stale_ideas,
+        check_session_gaps,
+        check_evolution_status,
+        check_pending_proposals,
+        check_recurring_errors,
+        check_cron_health,
+    ]
+
+    for check in checks:
+        try:
+            all_alerts.extend(check())
+        except Exception as e:
+            all_alerts.append({
+                "type": "check_error",
+                "severity": "low",
+                "title": f"Check {check.__name__} failed: {e}",
+            })
+
+    # Sort by severity
+    severity_order = {"high": 0, "medium": 1, "low": 2}
+    all_alerts.sort(key=lambda a: severity_order.get(a.get("severity", "low"), 3))
+
+    return all_alerts
+
+
+def format_text(alerts: list[dict]) -> str:
+    """Format alerts as readable text."""
+    if not alerts:
+        return "No proactive alerts. All clear."
+
+    severity_icons = {"high": "!!!", "medium": " ! ", "low": " . "}
+    lines = [f"NEXO Proactive Dashboard — {len(alerts)} alerts\n"]
+
+    current_severity = None
+    for a in alerts:
+        sev = a.get("severity", "low")
+        if sev != current_severity:
+            current_severity = sev
+            label = {"high": "URGENTE", "medium": "ATENCION", "low": "INFO"}.get(sev, sev)
+            lines.append(f"\n  [{label}]")
+        icon = severity_icons.get(sev, " . ")
+        lines.append(f"  {icon} {a['title']}")
+
+    return "\n".join(lines)
+
+
+def format_brief(alerts: list[dict]) -> str:
+    """One-liner summary."""
+    high = sum(1 for a in alerts if a.get("severity") == "high")
+    med = sum(1 for a in alerts if a.get("severity") == "medium")
+    low = sum(1 for a in alerts if a.get("severity") == "low")
+    if not alerts:
+        return "Dashboard: clean"
+    return f"Dashboard: {high} urgent, {med} attention, {low} info"
+
+
+def main():
+    output_json = "--json" in sys.argv
+    brief = "--brief" in sys.argv
+
+    alerts = run_all_checks()
+
+    if output_json:
+        print(json.dumps(alerts, indent=2, default=str))
+    elif brief:
+        print(format_brief(alerts))
+    else:
+        print(format_text(alerts))
+
+    # Exit code = number of high severity alerts
+    high_count = sum(1 for a in alerts if a.get("severity") == "high")
+    sys.exit(min(high_count, 125))
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-proactive-dashboard.py

@@ -38,6 +38,7 @@ def check_overdue_followups() -> list[dict]:
         SELECT id, description, date, created_at, reasoning
         FROM followups
         WHERE status NOT LIKE 'COMPLETED%'
+        AND status NOT IN ('DELETED','archived','blocked','waiting')
         AND date IS NOT NULL AND date != ''
         ORDER BY date ASC
     """).fetchall()