nexo-brain 1.4.0 → 1.4.1

package/src/scripts/nexo-brain-activation.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# nexo-brain-activation.sh — NF24: Activación Espontánea
+# Lee user_model.json, detecta shifts significativos y genera insights
+# para el arranque de NEXO. Si no hay nada relevante: exit 0 sin output.
+
+set -euo pipefail
+
+BRAIN_DIR="~/.nexo/brain"
+MODEL_FILE="$BRAIN_DIR/user_model.json"
+SUMMARIES_DIR="$BRAIN_DIR/daily_summaries"
+
+# --- Guardia: archivo imprescindible ---
+if [[ ! -f "$MODEL_FILE" ]]; then
+    exit 0
+fi
+
+# --- Python inline para parsear JSON y analizar ---
+python3 - <<'PYEOF'
+import json
+import sys
+import os
+import glob
+from datetime import datetime, timedelta
+
+BRAIN_DIR = os.path.expanduser("~/.nexo/brain")
+MODEL_FILE = os.path.join(BRAIN_DIR, "user_model.json")
+SUMMARIES_DIR = os.path.join(BRAIN_DIR, "daily_summaries")
+
+# ── Cargar modelo ──────────────────────────────────────────────────────────
+try:
+    with open(MODEL_FILE) as f:
+        model = json.load(f)
+except Exception:
+    sys.exit(0)
+
+insights = []
+
+# ── 1. Analizar evolution_log — últimas 3-5 entradas ─────────────────────
+evolution = model.get("evolution_log", [])
+recent = evolution[-5:] if len(evolution) >= 5 else evolution
+
+# Detectar entradas de los últimos 3 días
+today = datetime.now().date()
+cutoff = today - timedelta(days=3)
+
+recent_obs = []
+for entry in recent:
+    try:
+        entry_date = datetime.strptime(entry["date"], "%Y-%m-%d").date()
+        if entry_date >= cutoff:
+            recent_obs.append(entry)
+    except Exception:
+        pass
+
+if recent_obs:
+    for obs in recent_obs[-2:]:  # max 2 most recent
+        insights.append(obs["observation"].strip())
+
+# ── 2. Detectar cambios de traits >0.1 entre entradas (si hay histórico) ──
+# El modelo actual solo tiene snapshot actual; si en el futuro hay histórico
+# en evolution_log con trait deltas, se puede ampliar aquí.
+# Detect the most extreme trait as the dominant identity signal.
+traits = model.get("traits", {})
+if traits:
+    dominant = max(traits, key=lambda k: traits[k])
+    dominant_val = traits[dominant]
+    weakest = min(traits, key=lambda k: traits[k])
+    weakest_val = traits[weakest]
+    # Solo reportar si es muy extremo (>0.9 o <0.2) para no saturar
+    if dominant_val >= 0.9:
+        insights.append(f"Trait dominante: {dominant}={dominant_val} (máximo registrado)")
+    if weakest_val <= 0.2:
+        insights.append(f"Trait en mínimo: {weakest}={weakest_val} (baja tolerancia activa)")
+
+# ── 3. Contradicciones recientes (últimos 3 días) ─────────────────────────
+contradictions = model.get("contradictions", [])
+recent_contradictions = []
+for c in contradictions:
+    try:
+        c_date = datetime.strptime(c["date"], "%Y-%m-%d").date()
+        if c_date >= cutoff:
+            recent_contradictions.append(c)
+    except Exception:
+        pass
+
+for c in recent_contradictions:
+    insights.append(f"Contradicción detectada: {c['description'].strip()}")
+
+# ── 4. Foco activo actual ─────────────────────────────────────────────────
+current_focus = model.get("current_focus", [])
+# Solo incluir si hay focos (y no es el arranque inicial)
+if len(current_focus) > 0 and len(insights) == 0:
+    # Si no hay otros insights, reportar foco como contexto mínimo
+    focus_str = ", ".join(current_focus)
+    insights.append(f"Foco actual: {focus_str}")
+
+# ── 5. Goals: cambios active/dormant ─────────────────────────────────────
+goals_active = model.get("goals_active", [])
+goals_dormant = model.get("goals_dormant", [])
+# Si hay goals dormant, mencionarlos (pueden necesitar reactivación)
+if goals_dormant:
+    insights.append(f"Goal dormant: {goals_dormant[0]}")
+
+# ── Leer último daily summary ─────────────────────────────────────────────
+summary_text = ""
+try:
+    files = sorted(glob.glob(os.path.join(SUMMARIES_DIR, "*.md")))
+    if files:
+        with open(files[-1]) as f:
+            lines = [l.rstrip() for l in f.readlines() if l.strip()]
+        # Take up to 3 lines of content (exclude header)
+        content_lines = [l for l in lines if not l.startswith("# Resumen")]
+        summary_text = " | ".join(content_lines[:3])
+except Exception:
+    pass
+
+# ── Output ────────────────────────────────────────────────────────────────
+# Si no hay insights reales, salir sin output
+if not insights and not summary_text:
+    sys.exit(0)
+
+# Deduplicar y limitar
+seen = set()
+unique_insights = []
+for ins in insights:
+    key = ins[:60]
+    if key not in seen:
+        seen.add(key)
+        unique_insights.append(ins)
+
+if unique_insights:
+    print("BRAIN_INSIGHTS:")
+    for ins in unique_insights[:5]:
+        print(f"- {ins}")
+
+if summary_text:
+    print("RECENT_SUMMARY:")
+    print(summary_text[:400])
+
+PYEOF

package/src/scripts/nexo-evolution-run.py

@@ -319,7 +319,7 @@ def _create_review_followup(conn: sqlite3.Connection, cycle_num: int,
     public_items = [i for i in items if i.get("scope") == "public"]
     local_items = [i for i in items if i.get("scope") != "public"]
 
-    lines = [f"Evolution Cycle #{cycle_num} — {len(items)} propuestas para revisar."]
+    lines = [f"Evolution Cycle #{cycle_num} — {len(items)} proposals to review."]
     lines.append(f"Análisis: {analysis[:200]}")
     lines.append("")
 

package/src/scripts/nexo-followup-hygiene.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+NEXO Followup Hygiene — Weekly cleanup of followup/reminder statuses.
+
+Runs Sundays via LaunchAgent (or manually). Tasks:
+1. Normalize dirty statuses (COMPLETED YYYY-MM-DD → COMPLETED)
+2. Flag PENDING followups >14 days without updates as STALE
+3. Generate summary of orphaned/forgotten followups for synthesis
+
+No CLI needed — this is pure mechanical cleanup.
+"""
+
+import json
+import sqlite3
+import sys
+from datetime import datetime, date, timedelta
+from pathlib import Path
+
+NEXO_DB = Path.home() / ".nexo" / "nexo-mcp" / "nexo.db"
+COORD_DIR = Path.home() / ".nexo" / "coordination"
+LOG_FILE = Path.home() / ".nexo" / "logs" / "followup-hygiene.log"
+
+TODAY = date.today().isoformat()
+
+
+def log(msg):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def main():
+    log("=== Followup Hygiene starting ===")
+
+    if not NEXO_DB.exists():
+        log("nexo.db not found")
+        return
+
+    conn = sqlite3.connect(str(NEXO_DB))
+    conn.row_factory = sqlite3.Row
+
+    # 1. Normalize dirty statuses
+    dirty_f = conn.execute("SELECT COUNT(*) FROM followups WHERE status LIKE 'COMPLETED %'").fetchone()[0]
+    dirty_r = conn.execute("SELECT COUNT(*) FROM reminders WHERE status LIKE 'COMPLETED %'").fetchone()[0]
+
+    if dirty_f > 0:
+        conn.execute("UPDATE followups SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        log(f"Normalized {dirty_f} dirty followup statuses")
+
+    if dirty_r > 0:
+        conn.execute("UPDATE reminders SET status='COMPLETED' WHERE status LIKE 'COMPLETED %'")
+        log(f"Normalized {dirty_r} dirty reminder statuses")
+
+    # 2. Flag stale followups (PENDING >14 days, no updates)
+    cutoff = (date.today() - timedelta(days=14)).isoformat()
+    stale = conn.execute(
+        "SELECT id, description, date, updated_at FROM followups "
+        "WHERE status NOT LIKE 'COMPLETED%' AND status NOT LIKE 'COMPLETED%' "
+        "AND date != '' AND date < ? "
+        "ORDER BY date",
+        (cutoff,)
+    ).fetchall()
+
+    if stale:
+        log(f"Found {len(stale)} stale followups (>14 days overdue):")
+        for s in stale[:10]:
+            log(f"  {s['id']}: {s['description'][:60]} (due: {s['date']})")
+
+    # 3. Orphaned followups (no date, no recent update)
+    orphans = conn.execute(
+        "SELECT id, description FROM followups "
+        "WHERE status NOT LIKE 'COMPLETED%' AND status NOT LIKE 'COMPLETED%' "
+        "AND (date IS NULL OR date = '') "
+        "ORDER BY id"
+    ).fetchall()
+
+    if orphans:
+        log(f"Found {len(orphans)} orphaned followups (no date):")
+        for o in orphans[:10]:
+            log(f"  {o['id']}: {o['description'][:60]}")
+
+    conn.commit()
+    conn.close()
+
+    # 4. Write summary for synthesis
+    summary = {
+        "date": TODAY,
+        "dirty_normalized": dirty_f + dirty_r,
+        "stale_count": len(stale) if stale else 0,
+        "orphan_count": len(orphans) if orphans else 0,
+        "stale_ids": [s["id"] for s in stale[:20]] if stale else [],
+        "orphan_ids": [o["id"] for o in orphans[:20]] if orphans else [],
+    }
+
+    summary_file = COORD_DIR / "followup-hygiene-summary.json"
+    summary_file.parent.mkdir(parents=True, exist_ok=True)
+    summary_file.write_text(json.dumps(summary, indent=2))
+
+    log(f"Summary: {dirty_f + dirty_r} normalized, {len(stale) if stale else 0} stale, {len(orphans) if orphans else 0} orphans")
+    log("=== Followup Hygiene complete ===")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -68,7 +68,7 @@ def collect_data() -> dict:
     conn = sqlite3.connect(str(NEXO_DB))
     conn.row_factory = sqlite3.Row
 
-    # Diarios de hoy con autocrítica
+    # Today diaries with self-critique
     rows = conn.execute(
         "SELECT id, session_id, summary, self_critique, user_signals, "
         "mental_state, domain, created_at "
@@ -106,7 +106,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("sin autocrítica")
+        if d.get("self_critique") and not (d["self_critique"] or "").strip().lower().startswith("no self-critique")
     ]
 
     if not diaries_with_critique:
@@ -118,13 +118,13 @@ def consolidate_with_cli(data: dict) -> bool:
     if len(diaries_json) > 12000:
         diaries_json = diaries_json[:12000] + "\n... (truncado)"
 
-    prompt = f"""Eres el consolidador nocturno de NEXO. Tu trabajo es revisar las autocríticas
-del día y decidir cuáles merecen convertirse en reglas permanentes (feedback_postmortem_*.md).
+    prompt = f"""You are NEXO nightly consolidator. Your job is to review self-critiques
+from today and decide which deserve to become permanent rules (feedback_postmortem_*.md).
 
 FECHA: {data['date']}
-SESIONES HOY: {len(data['diaries'])} total, {len(diaries_with_critique)} con autocrítica
+SESSIONS TODAY: {len(data['diaries'])} total, {len(diaries_with_critique)} with self-critique
 
-DIARIOS CON AUTOCRÍTICA:
+DIARIES WITH SELF-CRITIQUE:
 {diaries_json}
 
 FEEDBACKS POSTMORTEM QUE YA EXISTEN ({len(data['existing_feedbacks'])}):
@@ -138,44 +138,44 @@ INSTRUCCIONES:
 1. Lee cada self_critique y entiende su SIGNIFICADO (no cuentes palabras).
 
 2. PROMOVER a feedback permanente SOLO SI:
-   - Un patrón aparece en 2+ sesiones diferentes del día (por significado, no texto literal)
+   - A pattern appears in 2+ different sessions today (by meaning, not literal text)
    - O the user corrigió explícitamente (user_signals contiene corrección)
-   - Y la autocrítica contiene una ACCIÓN CONCRETA que prevenga un error futuro
+   - Y the self-critique contains a CONCRETE ACTION that prevents a future error
    - Y NO existe ya un feedback similar en los existentes
 
 3. NO promover si:
-   - Es una respuesta negativa ("No pasó nada", "sesión limpia")
-   - Es genérica sin acción concreta
-   - Ya existe un feedback que cubre el mismo tema
+   - It is a negative response ("No pasó nada", "sesión limpia")
+   - It is generic without concrete action
+   - A feedback already exists covering the same topic
 
-4. Para cada regla a promover, crea el archivo con Write en {MEMORY_DIR}/:
+4. For each rule to promote, create the file with Write en {MEMORY_DIR}/:
    Nombre: feedback_postmortem_[slug_descriptivo].md
    Formato:
    ---
-   name: [título descriptivo]
-   description: Regla de comportamiento extraída de autocrítica — patrón recurrente
+   name: [descriptive title]
+   description: Behavioral rule extracted from self-critique — recurring pattern
    type: feedback
    ---
 
-   [Descripción clara del patrón y la regla]
+   [Clear description of the pattern and rule]
 
-   **Why:** [Por qué esto importa — con evidencia de las sesiones]
-   **How to apply:** [Cuándo y cómo aplicar esta regla]
+   **Why:** [Why this matters — with evidence from sessions]
+   **How to apply:** [When and how to apply this rule]
 
-5. Escribe el resumen diario en ~/.nexo/coordination/postmortem-daily.md:
+5. Write the daily summary en ~/.nexo/coordination/postmortem-daily.md:
    # Post-Mortem Daily — {data['date']}
-   Sesiones: X | Autocríticas: Y | Promovidos: Z
+   Sessions: X | Self-critiques: Y | Promoted: Z
 
-   ## Autocríticas del día (resumen)
-   [Lista breve]
+   ## Self-critiques of the day (summary)
+   [Brief list]
 
    ## Promovido a memoria permanente
-   [Lo que promoviste y por qué]
+   [What you promoted and why]
 
-   ## Descartado (y por qué)
-   [Lo que NO promoviste y la razón]
+   ## Discarded (and why)
+   [What you did NOT promote and why]
 
-Ejecuta sin preguntar."""
+Execute without asking."""
 
     log(f"Stage 2: Invoking Claude CLI (opus) with {len(diaries_with_critique)} critiques...")
 

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

@@ -0,0 +1,118 @@
+#!/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 sqlite3
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_DB = Path.home() / ".nexo" / "nexo-mcp" / "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())