nexo-brain 0.2.1 → 0.3.2

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

@@ -9,7 +9,7 @@ and writes permanent rules to memory files so they survive forever.
 Three layers:
 1. Session → self_critique field in session_diary (captured at session end)
 2. Daily → this script consolidates all critiques from today
-3. Permanent → writes to feedback_*.md files
+3. Permanent → writes to feedback_*.md files + MEMORY.md index
 
 Only creates permanent memory for patterns that:
 - Appear 2+ times in the same day, OR
@@ -26,23 +26,25 @@ from collections import Counter
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-sys.path.insert(0, str(NEXO_HOME / "src"))
+# Add nexo-mcp to path for cognitive engine
+sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
 
 HOME = Path.home()
-NEXO_DB = NEXO_HOME / "nexo.db"
-SESSION_BUFFER = NEXO_HOME / "brain" / "session_buffer.jsonl"
-MEMORY_DIR = NEXO_HOME / "memory"
-CONSOLIDATION_LOG = NEXO_HOME / "logs" / "postmortem-consolidation.log"
-HISTORY_FILE = NEXO_HOME / "coordination" / "postmortem-history.json"
+NEXO_DB = HOME / "claude" / "nexo-mcp" / "nexo.db"
+SESSION_BUFFER = HOME / "claude" / "brain" / "session_buffer.jsonl"
+MEMORY_DIR = HOME / ".claude" / "projects" / f"-Users-{os.environ.get('USER', 'user')}" / "memory"
+MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
+CONSOLIDATION_LOG = HOME / "claude" / "logs" / "postmortem-consolidation.log"
+HISTORY_FILE = HOME / "claude" / "coordination" / "postmortem-history.json"
 
 TODAY = date.today()
 TODAY_STR = TODAY.isoformat()
 
 CORRECTION_KEYWORDS = [
-    "corrected", "wrong again", "already told", "repeating", "should not",
-    "why not", "again", "tired", "always waiting", "not proactive", "reactive",
-    "not doing", "error", "wrong", "failure", "frustrat"
+    "corrig", "frustrad", "no lo entiend", "exig", "repet",
+    "no debería", "por qué no", "otra vez", "ya te dije",
+    "cansando", "siempre espera", "no te adelant", "reactivo",
+    "no haces", "error", "mal", "fallo", "irritad"
 ]
 
 
@@ -99,13 +101,13 @@ def extract_actionable_rules(critiques: list[str]) -> list[str]:
     """Extract concrete, actionable rules from self-critique text."""
     rules = []
     for critique in critiques:
-        if not critique or critique.strip().lower().startswith("no self-critique"):
+        if not critique or critique.strip().lower().startswith("sin autocrítica"):
             continue
         # Each non-empty critique is a potential rule
         # Clean up and normalize
         for line in critique.split("\n"):
             line = line.strip().lstrip("- ").strip()
-            if len(line) > 20:
+            if len(line) > 20 and not line.lower().startswith("sin "):
                 rules.append(line)
     return rules
 
@@ -155,23 +157,22 @@ def write_permanent_rule(rule_title: str, rule_content: str, source_critiques: l
         log(f"  File already exists: {filename}, skipping")
         return None
 
-    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
     content = f"""---
 name: {rule_title}
-description: Behavioral rule extracted from post-mortem self-critique — recurring pattern detected
+description: Regla de comportamiento extraída de autocrítica post-mortem — patrón recurrente detectado
 type: feedback
 ---
 
 {rule_content}
 
-**Why:** Pattern detected across multiple sessions where NEXO failed in this aspect. The user should not have to correct the same issue twice.
+**Why:** Patrón detectado en múltiples sesiones donde NEXO falló en este aspecto. The user should not tener que corregir lo mismo dos veces.
 
-**How to apply:** Verify this rule at the start of each session and before presenting work as complete.
+**How to apply:** Verificar esta regla al inicio de cada sesión y antes de presentar trabajo como completado.
 
-**Evidence (original self-critiques):**
+**Evidencia (autocríticas originales):**
 """
     for i, critique in enumerate(source_critiques[:3], 1):
-        content += f"- Session {i}: {critique[:200]}\n"
+        content += f"- Sesión {i}: {critique[:200]}\n"
 
     filepath.write_text(content)
     log(f"  Written permanent rule: {filename}")
@@ -270,12 +271,14 @@ def process_sensory_register():
                     "matches": patterns[:3],
                 })
 
-            # Ingest into STM as sensory — detect domain from content keywords
+            # Ingest into STM as sensory
+            # Customize domain keywords for your own projects
             domain = ""
-            content_lower = content.lower()
-            # Domain detection is generic — users can extend this
-            if any(w in content_lower for w in ["nexo", "cognitive", "guard"]):
+            if any(w in content.lower() for w in ["nexo", "cognitive", "guard"]):
                 domain = "nexo"
+            # Add your own project domains here:
+            # elif any(w in content.lower() for w in ["myproject", "keyword"]):
+            #     domain = "myproject"
 
             cognitive.ingest_sensory(
                 content=content,
@@ -310,7 +313,7 @@ def archive_sensory_buffer():
         return
 
     cutoff = (datetime.now() - timedelta(hours=48)).isoformat()
-    archive_dir = NEXO_HOME / "brain" / "session_archive"
+    archive_dir = HOME / "claude" / "brain" / "session_archive"
     archive_dir.mkdir(parents=True, exist_ok=True)
 
     keep_lines = []
@@ -358,7 +361,7 @@ def archive_sensory_buffer():
 def analyze_force_events():
     """Analyze --force dissonance resolutions from today.
 
-    When user uses --force, NEXO obeyed without discussion. The nocturnal
+    When the user uses --force, NEXO obeyed without discussion. The nocturnal
     process must now ask: was the old memory wrong, or was the user taking
     conscious technical debt?
 
@@ -412,7 +415,7 @@ def analyze_force_events():
             log(f"  PARADIGM SHIFT CANDIDATE: LTM #{mem_id} force-overridden {total_overrides}x total")
             log(f"    Content: {mem['content'][:120]}")
             log(f"    Action: Decaying strength from {mem['strength']:.2f} to 0.3")
-            # Auto-decay — if it's been overridden 3+ times, user clearly disagrees
+            # Auto-decay — if it's been overridden 3+ times, User clearly disagrees
             db.execute(
                 "UPDATE ltm_memories SET strength = 0.3, tags = CASE WHEN tags LIKE '%paradigm_candidate%' THEN tags ELSE tags || ',paradigm_candidate' END WHERE id = ?",
                 (mem_id,)
@@ -444,7 +447,7 @@ def main():
         critique = d.get("self_critique") or ""
         signals = d.get("user_signals") or ""
 
-        if critique and not critique.strip().lower().startswith("no self-critique"):
+        if critique and not critique.strip().lower().startswith("sin autocrítica"):
             today_critiques.append(critique)
 
         if has_correction_signals(signals):
@@ -487,8 +490,8 @@ def main():
                     overlap = len(words_i & words_j) / min(len(words_i), len(words_j))
                     if overlap > 0.5 and not rule_already_permanent(rule, history):
                         new_permanent.append({
-                            "title": f"Repeated pattern: {rule[:60]}",
-                            "content": f"Detected 2+ times in the same day:\n- {rule}\n- {other}",
+                            "title": f"Patrón repetido: {rule[:60]}",
+                            "content": f"Detectado 2+ veces en el mismo día:\n- {rule}\n- {other}",
                             "sources": [rule, other],
                         })
 
@@ -512,8 +515,8 @@ def main():
 
         if len(matching_days) >= 2 and not rule_already_permanent(today_rule, history):  # 2 historical + today = 3
             new_permanent.append({
-                "title": f"Recurring pattern ({len(matching_days)+1} days): {today_rule[:50]}",
-                "content": f"Detected on {len(matching_days)+1} different days:\n- Today: {today_rule}\n- Previous days: {', '.join(sorted(matching_days)[:5])}",
+                "title": f"Patrón recurrente ({len(matching_days)+1} días): {today_rule[:50]}",
+                "content": f"Detectado en {len(matching_days)+1} días diferentes:\n- Hoy: {today_rule}\n- Días previos: {', '.join(sorted(matching_days)[:5])}",
                 "sources": [today_rule],
             })
 
@@ -523,7 +526,7 @@ def main():
         if critique and not rule_already_permanent(critique, history):
             new_permanent.append({
                 "title": f"User correction: {critique[:50]}",
-                "content": f"User explicitly corrected this behavior.\nSignals: {cc['signals'][:200]}\nSelf-critique: {critique[:300]}",
+                "content": f"The user corrected explícitamente este comportamiento.\nSeñales: {cc['signals'][:200]}\nAutocrítica: {critique[:300]}",
                 "sources": [critique],
             })
 
@@ -537,26 +540,25 @@ def main():
     else:
         log("No patterns qualify for permanent promotion today.")
 
-    # Write daily summary
-    summary_file = NEXO_HOME / "coordination" / "postmortem-daily.md"
+    # Write daily summary to synthesis
+    summary_file = HOME / "claude" / "coordination" / "postmortem-daily.md"
     summary_lines = [
         f"# Post-Mortem Daily — {TODAY_STR}",
-        f"Sessions: {len(diaries)} | Self-critiques: {len(today_critiques)} | User corrections: {len(correction_critiques)}",
+        f"Sesiones: {len(diaries)} | Autocríticas: {len(today_critiques)} | User corrections: {len(correction_critiques)}",
         "",
     ]
     if today_critiques:
-        summary_lines.append("## Today's Self-Critiques")
+        summary_lines.append("## Autocríticas del día")
         for c in today_critiques:
             summary_lines.append(f"- {c[:200]}")
         summary_lines.append("")
     if new_permanent:
-        summary_lines.append("## Promoted to Permanent Memory")
+        summary_lines.append("## Promovido a memoria permanente")
         for r in new_permanent:
             summary_lines.append(f"- {r['title']}")
     else:
-        summary_lines.append("## Nothing promoted today")
+        summary_lines.append("## Nada promovido hoy")
 
-    summary_file.parent.mkdir(parents=True, exist_ok=True)
     summary_file.write_text("\n".join(summary_lines))
     log(f"Written daily summary: {summary_file}")
 
@@ -576,7 +578,7 @@ def main():
 
     # Register successful run for catch-up
     try:
-        state_file = NEXO_HOME / "operations" / ".catchup-state.json"
+        state_file = HOME / "claude" / "operations" / ".catchup-state.json"
         state = json.loads(state_file.read_text()) if state_file.exists() else {}
         state["postmortem"] = datetime.now().isoformat()
         state_file.write_text(json.dumps(state, indent=2))

package/src/scripts/nexo-sleep.py

@@ -21,8 +21,8 @@ Stage C — Learning Consolidation (Python pure, always runs):
   C4: Contradiction detection (NUNCA pairs in same category)
 
 Stage B — Intelligent pruning (Claude CLI, conditional):
-  Only activates if nexo.db preferences table has >5 rows,
-  or other configurable thresholds are exceeded.
+  Only activates if MEMORY.md >170 lines, nexo.db preferences table has >5 rows,
+  or claude-mem.db has >500 observations >60 days.
   Uses Claude CLI (sonnet) to compress and prune.
 
 Zero external dependencies beyond stdlib + sqlite3. Claude CLI for Stage B only.
@@ -39,13 +39,12 @@ import sys
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
 # ─── Paths ────────────────────────────────────────────────────────────────────
-BRAIN_DIR = NEXO_HOME / "brain"
-COORD_DIR = NEXO_HOME / "coordination"
-MEMORY_DIR = NEXO_HOME / "memory"
-DAEMON_LOGS_DIR = NEXO_HOME / "daemon" / "logs"
+CLAUDE_DIR = Path.home() / "claude"
+BRAIN_DIR = CLAUDE_DIR / "brain"
+COORD_DIR = CLAUDE_DIR / "coordination"
+MEMORY_DIR = CLAUDE_DIR / "memory"
+DAEMON_LOGS_DIR = CLAUDE_DIR / "daemon" / "logs"
 
 DAILY_SUMMARIES_DIR = BRAIN_DIR / "daily_summaries"
 SESSION_ARCHIVE_DIR = BRAIN_DIR / "session_archive"
@@ -55,7 +54,10 @@ HEARTBEAT_LOG = COORD_DIR / "heartbeat-log.json"
 REFLECTION_LOG = COORD_DIR / "reflection-log.json"
 SLEEP_LOG = COORD_DIR / "sleep-log.json"
 
-NEXO_DB = NEXO_HOME / "nexo.db"
+MEMORY_MD = Path.home() / ".claude" / "projects" / f"-Users-{os.environ.get('USER', 'user')}" / "memory" / "MEMORY.md"
+NEXO_DB = Path.home() / "claude" / "nexo-mcp" / "nexo.db"
+CLAUDE_MEM_DB = Path.home() / ".claude-mem" / "claude-mem.db"
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
 
 LAST_RUN_FILE = COORD_DIR / "sleep-last-run"
 LOCK_FILE = COORD_DIR / "sleep.lock"
@@ -290,7 +292,7 @@ def stage_a_cleanup() -> dict:
 
     # A8: Delete cortex/logs/*.log >7 days, truncate launchd logs >5MB
     cutoff_7 = TODAY - timedelta(days=7)
-    cortex_logs = NEXO_HOME / "cortex" / "logs"
+    cortex_logs = Path.home() / "claude" / "cortex" / "logs"
     if cortex_logs.exists():
         for f in cortex_logs.glob("*.log"):
             if f.name.startswith("launchd-"):
@@ -474,12 +476,14 @@ def stage_c_learning_consolidation() -> dict:
     stats["potential_duplicates"] = duplicates
 
     # C4: Contradiction detection — NUNCA pairs in same category
-    nunca_entries = [p for p in parsed if "nunca" in p["title"].lower() or "never" in p["title"].lower()]
+    nunca_entries = [p for p in parsed if "nunca" in p["title"].lower()]
     contradictions = []
     for nunca in nunca_entries:
         if len(contradictions) >= 5:
             break
-        nunca_words_no_nunca = nunca["words"] - {"nunca", "never"}
+        # Look for same-category entries that don't contain NUNCA
+        # and whose remaining words overlap significantly (same subject, opposite stance)
+        nunca_words_no_nunca = nunca["words"] - {"nunca"}
         for other in parsed:
             if len(contradictions) >= 5:
                 break
@@ -487,8 +491,9 @@ def stage_c_learning_consolidation() -> dict:
                 continue
             if other["category"] != nunca["category"]:
                 continue
-            if "nunca" in other["title"].lower() or "never" in other["title"].lower():
+            if "nunca" in other["title"].lower():
                 continue
+            # Check if they share meaningful subject words
             overlap = _word_overlap(nunca_words_no_nunca, other["words"])
             if overlap >= 0.50:
                 contradictions.append({
@@ -518,11 +523,24 @@ def check_stage_b_conditions() -> dict:
     Returns dict with condition results and whether to trigger.
     """
     conditions = {
-        "preferences_count": 0,
+        "memory_md_lines": 0,
+        "memory_md_over_limit": False,
+        "preferences_auto_sections": 0,
         "preferences_over_limit": False,
+        "claude_mem_old_observations": 0,
+        "claude_mem_over_limit": False,
         "should_trigger": False,
     }
 
+    # Check MEMORY.md line count
+    if MEMORY_MD.exists():
+        try:
+            lines = MEMORY_MD.read_text().splitlines()
+            conditions["memory_md_lines"] = len(lines)
+            conditions["memory_md_over_limit"] = len(lines) > 170
+        except Exception as e:
+            log(f"Stage B check: WARN reading MEMORY.md: {e}")
+
     # Check preferences count in SQLite
     if NEXO_DB.exists():
         try:
@@ -531,13 +549,16 @@ def check_stage_b_conditions() -> dict:
             cursor.execute("SELECT COUNT(*) FROM preferences")
             count = cursor.fetchone()[0]
             conn.close()
-            conditions["preferences_count"] = count
+            conditions["preferences_auto_sections"] = count
             conditions["preferences_over_limit"] = count > 5
         except Exception as e:
             log(f"Stage B check: WARN reading nexo.db preferences: {e}")
 
+    # Check claude-mem.db observations >60 days
+    if CLAUDE_MEM_DB.exists():
         try:
             cutoff_epoch = int((datetime.now() - timedelta(days=60)).timestamp() * 1000)
+            conn = sqlite3.connect(str(CLAUDE_MEM_DB))
             cursor = conn.cursor()
             cursor.execute(
                 "SELECT COUNT(*) FROM observations WHERE created_at_epoch < ?",
@@ -545,10 +566,15 @@ def check_stage_b_conditions() -> dict:
             )
             count = cursor.fetchone()[0]
             conn.close()
+            conditions["claude_mem_old_observations"] = count
+            conditions["claude_mem_over_limit"] = count > 500
         except Exception as e:
+            log(f"Stage B check: WARN reading claude-mem.db: {e}")
 
     conditions["should_trigger"] = (
-        conditions["preferences_over_limit"]
+        conditions["memory_md_over_limit"]
+        or conditions["preferences_over_limit"]
+        or conditions["claude_mem_over_limit"]
     )
 
     return conditions
@@ -558,36 +584,54 @@ def build_stage_b_prompt(conditions: dict) -> str:
     """Build the prompt for Claude CLI based on which conditions triggered."""
     tasks = []
 
-    if conditions["preferences_over_limit"]:
-        tasks.append(f"""TASK: preferences in SQLite ({conditions['preferences_count']} records)
-DB: {NEXO_DB}, table: preferences (columns: key, value, category, updated_at)
-Connect with sqlite3. Delete duplicate preferences (same key) keeping the most recent.
-Delete preferences with updated_at older than 30 days if there is a newer duplicate.
-Report how many records were deleted.""")
+    if conditions["memory_md_over_limit"]:
+        tasks.append(f"""TAREA 1: MEMORY.md ({conditions['memory_md_lines']} lineas, limite 200)
+Archivo: {MEMORY_MD}
+Lee con Read tool, comprime incidentes resueltos >21 dias, fusiona duplicados, mantener <180 lineas.
+PRESERVA toda la estructura de secciones existente. No elimines secciones enteras.""")
 
-Connect with sqlite3. Delete old low-value observations (discovery_tokens < 300 and >60 days old).
-Preserve anything marked CRITICAL, any credentials, tokens, API keys, or infrastructure details.
-Report how many records were deleted.""")
+    if conditions["preferences_over_limit"]:
+        tasks.append(f"""TAREA 2: preferences en SQLite ({conditions['preferences_auto_sections']} registros)
+DB: {NEXO_DB}, tabla: preferences (columnas: key, value, category, updated_at)
+Conecta con sqlite3. Elimina preferencias duplicadas (mismo key) manteniendo la mas reciente.
+Elimina preferencias con updated_at mas antiguo de 30 dias si hay un duplicado mas reciente.
+Reporta cuantos registros eliminaste.""")
+
+    if conditions["claude_mem_over_limit"]:
+        tasks.append(f"""TAREA 3: claude-mem observations ({conditions['claude_mem_old_observations']} registros >60d)
+DB: {CLAUDE_MEM_DB}
+Conecta con sqlite3. Ejecuta:
+  DELETE FROM observations WHERE created_at_epoch < {int((datetime.now() - timedelta(days=60)).timestamp() * 1000)}
+    AND discovery_tokens < 300
+    AND id NOT IN (SELECT id FROM observations WHERE
+        title LIKE '%CRITICO%' OR title LIKE '%MAXIMA%'
+        OR title LIKE '%credential%' OR title LIKE '%token%' OR title LIKE '%API%'
+        OR narrative LIKE '%CRITICO%' OR narrative LIKE '%MAXIMA%')
+  LIMIT 200;
+Luego: DELETE FROM observations_fts WHERE rowid NOT IN (SELECT id FROM observations);
+Luego: VACUUM;
+Reporta cuantos registros eliminaste.""")
 
     if not tasks:
         return ""
 
     tasks_str = "\n\n".join(tasks)
 
-    return f"""You are NEXO Sleep System. Your job is to PRUNE memory.
-NOT interactive. Do NOT wait for input. Execute the following tasks and exit.
+    return f"""Eres NEXO Sleep System. Tu trabajo es PODAR la memoria.
+NO eres interactivo. NO esperas input. Ejecuta las siguientes tareas y sal.
 
-ABSOLUTE RULES:
-- NEVER delete credentials, tokens, account IDs, API endpoints, keys, secrets.
-- NEVER delete operational rules marked as "CRITICAL".
-- YES to merging redundant sections.
-- YES to deleting obsolete technical info (fixed >30 days ago and never referenced after).
-- YES to compressing long paragraphs into concise bullets.
-- Every line you delete must have a clear reason. When in doubt, do NOT delete.
+REGLAS ABSOLUTAS:
+- NUNCA borres credenciales, tokens, IDs de cuentas, API endpoints, claves, secrets.
+- NUNCA borres reglas operativas marcadas como "CRITICO" o "MAXIMA PRIORIDAD".
+- NUNCA borres informacion sobre infraestructura (servidores, repos, deploys).
+- SI puedes fusionar secciones redundantes.
+- SI puedes eliminar informacion tecnica obsoleta (arreglada hace >30 dias y nunca referenciada despues).
+- SI puedes comprimir parrafos largos en bullets concisos.
+- Cada linea que elimines debe tener una razon clara. En caso de duda, NO borres.
 
 {tasks_str}
 
-When done, print a JSON summary of actions taken."""
+Al terminar, imprime un resumen JSON con las acciones realizadas."""
 
 
 def run_stage_b(conditions: dict) -> dict:
@@ -596,6 +640,8 @@ def run_stage_b(conditions: dict) -> dict:
     if not prompt:
         return {"skipped": True, "reason": "No tasks to run"}
 
+    if not CLAUDE_CLI.exists():
+        return {"error": f"Claude CLI not found at {CLAUDE_CLI}"}
 
     log("Stage B: Invoking Claude CLI (sonnet)...")
 
@@ -606,9 +652,10 @@ def run_stage_b(conditions: dict) -> dict:
         env.pop("CLAUDE_CODE", None)
 
         result = subprocess.run(
+            [str(CLAUDE_CLI), "-p", prompt, "--model", "sonnet"],
             capture_output=True,
             text=True,
-            timeout=300,
+            timeout=600,
             env=env
         )
 
@@ -633,7 +680,7 @@ def run_stage_b(conditions: dict) -> dict:
         }
 
     except subprocess.TimeoutExpired:
-        log("Stage B: Claude CLI timed out (300s)")
+        log("Stage B: Claude CLI timed out (600s)")
         return {"error": "timeout"}
     except Exception as e:
         log(f"Stage B: Exception: {e}")
@@ -710,8 +757,12 @@ def main():
             conditions = check_stage_b_conditions()
             run_log["stage_b_conditions"] = conditions
 
-            log(f"  nexo.db preferences: {conditions['preferences_count']} rows "
+            log(f"  MEMORY.md: {conditions['memory_md_lines']} lines "
+                f"(trigger={conditions['memory_md_over_limit']})")
+            log(f"  nexo.db preferences: {conditions['preferences_auto_sections']} rows "
                 f"(trigger={conditions['preferences_over_limit']})")
+            log(f"  claude-mem old observations: {conditions['claude_mem_old_observations']} "
+                f"(trigger={conditions['claude_mem_over_limit']})")
 
             if conditions["should_trigger"]:
                 log("Stage B: Conditions met, running intelligent pruning...")
@@ -731,7 +782,7 @@ def main():
         # Register successful run for catch-up
         try:
             import json as _json
-            _state_file = NEXO_HOME / "operations" / ".catchup-state.json"
+            _state_file = Path.home() / "claude" / "operations" / ".catchup-state.json"
             _state = _json.loads(_state_file.read_text()) if _state_file.exists() else {}
             _state["sleep"] = datetime.now().isoformat()
             _state_file.write_text(_json.dumps(_state, indent=2))