nexo-brain 1.2.3 → 1.4.0

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

@@ -1,55 +1,46 @@
 #!/usr/bin/env python3
 """
-NEXO Post-Mortem Consolidator — Daily behavioral learning extraction.
+NEXO Post-Mortem Consolidator v2 — The brain consolidates memories.
 
-Runs daily at 23:30 via LaunchAgent. Reads all session diaries from today,
-extracts self_critique entries, identifies RECURRING behavioral patterns,
-and writes permanent rules to memory files so they survive forever.
+Before: 595 lines of word-overlap al 50% para detectar "patrones".
+Now: Collects data, passes them to CLI which UNDERSTANDS what it reads.
 
-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 + MEMORY.md index
+Runs daily at 23:30 via LaunchAgent. Reads session diaries from today,
+passes them to Claude CLI (opus) which decides what deserves permanent memory.
 
-Only creates permanent memory for patterns that:
-- Appear 2+ times in the same day, OR
-- Appear in 3+ different days (checked against history), OR
-- User explicitly corrected NEXO (user_signals contains correction keywords)
+Stage 1 — Data collection (pure Python):
+  Query session diaries, existing feedbacks, history.
+
+Stage 2 — Intelligence (Claude CLI opus):
+  Read diaries, understand patterns, decide what to promote.
+
+Stage 3 — Sensory Register + Force analysis (pure Python):
+  Process cognitive events. Kept from v1 — genuinely mechanical.
 """
 
 import json
 import os
-import re
 import sqlite3
+import subprocess
 import sys
-from collections import Counter
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
-# Add NEXO_HOME to path for cognitive engine
-NEXO_HOME = os.environ.get("NEXO_HOME", str(Path.home() / ".nexo"))
-sys.path.insert(0, NEXO_HOME)
-# Fallback for development installs
-sys.path.insert(0, str(Path.home() / "claude" / "nexo-mcp"))
+# Add nexo to path for cognitive engine (Stage 3)
+sys.path.insert(0, str(Path.home() / ".nexo"))
 
 HOME = Path.home()
-NEXO_DB = Path(NEXO_HOME) / "nexo.db"
-SESSION_BUFFER = Path(NEXO_HOME) / "brain" / "session_buffer.jsonl"
-MEMORY_DIR = HOME / ".claude" / "projects" / f"-Users-{os.environ.get('USER', 'user')}" / "memory"
+NEXO_DB = HOME / ".nexo" / "nexo.db"
+MEMORY_DIR = HOME / ".nexo" / "memory"
 MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
-CONSOLIDATION_LOG = HOME / "claude" / "logs" / "postmortem-consolidation.log"
-HISTORY_FILE = HOME / "claude" / "coordination" / "postmortem-history.json"
+HISTORY_FILE = HOME / ".nexo" / "coordination" / "postmortem-history.json"
+CONSOLIDATION_LOG = HOME / ".nexo" / "logs" / "postmortem-consolidation.log"
+CLAUDE_CLI = HOME / ".local" / "bin" / "claude"
+SESSION_BUFFER = HOME / ".nexo" / "brain" / "session_buffer.jsonl"
 
 TODAY = date.today()
 TODAY_STR = TODAY.isoformat()
 
-CORRECTION_KEYWORDS = [
-    "corrig", "frustrat", "don't understand", "demand", "repeat",
-    "shouldn't", "why not", "again", "already told you",
-    "tiring", "always wait", "not proactive", "reactive",
-    "don't do", "error", "wrong", "failure", "irritat"
-]
-
 
 def log(msg: str):
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -60,152 +51,184 @@ def log(msg: str):
         f.write(line + "\n")
 
 
-def get_today_diaries() -> list[dict]:
-    """Get all session diaries from today with self_critique."""
+# ─── Stage 1: Data Collection (pure Python) ─────────────────────────────────
+
+def collect_data() -> dict:
+    """Collect all data the CLI needs to make decisions."""
+    data = {
+        "date": TODAY_STR,
+        "diaries": [],
+        "existing_feedbacks": [],
+        "history_summary": {},
+    }
+
     if not NEXO_DB.exists():
-        return []
+        return data
+
     conn = sqlite3.connect(str(NEXO_DB))
     conn.row_factory = sqlite3.Row
+
+    # Diarios de hoy con autocrítica
     rows = conn.execute(
-        "SELECT id, session_id, summary, self_critique, user_signals, mental_state, domain, created_at "
+        "SELECT id, session_id, summary, self_critique, user_signals, "
+        "mental_state, domain, created_at "
         "FROM session_diary WHERE date(created_at) = ? ORDER BY created_at",
         (TODAY_STR,)
     ).fetchall()
+    data["diaries"] = [dict(r) for r in rows]
+
     conn.close()
-    return [dict(r) for r in rows]
 
+    # Feedbacks postmortem existentes (nombres, para no duplicar)
+    data["existing_feedbacks"] = [
+        f.stem for f in MEMORY_DIR.glob("feedback_postmortem_*.md")
+    ]
 
-def get_historical_critiques(days: int = 30) -> list[dict]:
-    """Get self_critique from the last N days for pattern detection."""
-    if not NEXO_DB.exists():
-        return []
-    since = (TODAY - timedelta(days=days)).isoformat()
-    conn = sqlite3.connect(str(NEXO_DB))
-    conn.row_factory = sqlite3.Row
-    rows = conn.execute(
-        "SELECT self_critique, user_signals, created_at "
-        "FROM session_diary WHERE date(created_at) >= ? AND self_critique != '' "
-        "ORDER BY created_at",
-        (since,)
-    ).fetchall()
-    conn.close()
-    return [dict(r) for r in rows]
+    # Resumen del historial
+    if HISTORY_FILE.exists():
+        try:
+            history = json.loads(HISTORY_FILE.read_text())
+            data["history_summary"] = {
+                "total_permanent_rules": len(history.get("permanent_rules", [])),
+                "days_tracked": len(history.get("days", {})),
+                "recent_rules": history.get("permanent_rules", [])[-10:],
+            }
+        except Exception:
+            pass
 
+    return data
 
-def has_correction_signals(signals: str) -> bool:
-    """Check if user_signals indicate corrections."""
-    if not signals:
-        return False
-    lower = signals.lower()
-    return any(kw in lower for kw in CORRECTION_KEYWORDS)
 
+# ─── Stage 2: Intelligence (Claude CLI opus) ────────────────────────────────
 
-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"):
-            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 and not line.lower().startswith("no "):
-                rules.append(line)
-    return rules
+def consolidate_with_cli(data: dict) -> bool:
+    """El cerebro consolida — CLI decide qué promover."""
 
+    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")
+    ]
 
-def load_history() -> dict:
-    """Load consolidation history to detect recurring patterns."""
-    if HISTORY_FILE.exists():
-        try:
-            return json.loads(HISTORY_FILE.read_text())
-        except Exception:
-            return {"days": {}, "permanent_rules": []}
-    return {"days": {}, "permanent_rules": []}
-
-
-def save_history(history: dict):
-    """Save consolidation history."""
-    HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-    # Keep last 90 days
-    cutoff = (TODAY - timedelta(days=90)).isoformat()
-    history["days"] = {k: v for k, v in history["days"].items() if k >= cutoff}
-    HISTORY_FILE.write_text(json.dumps(history, ensure_ascii=False, indent=2))
-
-
-def rule_already_permanent(rule: str, history: dict) -> bool:
-    """Check if a similar rule is already in permanent memory."""
-    rule_lower = rule.lower()
-    for existing in history.get("permanent_rules", []):
-        # Simple similarity: if >60% of words overlap
-        existing_words = set(existing.lower().split())
-        rule_words = set(rule_lower.split())
-        if not rule_words:
-            return True
-        overlap = len(existing_words & rule_words) / len(rule_words)
-        if overlap > 0.6:
-            return True
-    return False
+    if not diaries_with_critique:
+        log("All sessions clean or trivial. Nothing to consolidate.")
+        return True
 
+    # Preparar datos para el CLI (truncar para no exceder contexto)
+    diaries_json = json.dumps(diaries_with_critique, ensure_ascii=False, indent=1)
+    if len(diaries_json) > 12000:
+        diaries_json = diaries_json[:12000] + "\n... (truncado)"
 
-def write_permanent_rule(rule_title: str, rule_content: str, source_critiques: list[str]):
-    """Write a new permanent feedback memory file."""
-    # Generate filename
-    slug = re.sub(r'[^a-z0-9]+', '_', rule_title.lower())[:50].strip('_')
-    filename = f"feedback_postmortem_{slug}.md"
-    filepath = MEMORY_DIR / filename
+    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).
 
-    if filepath.exists():
-        log(f"  File already exists: {filename}, skipping")
-        return None
+FECHA: {data['date']}
+SESIONES HOY: {len(data['diaries'])} total, {len(diaries_with_critique)} con autocrítica
 
-    content = f"""---
-name: {rule_title}
-description: Behavioral rule extracted from post-mortem self-critique — recurring pattern detected
-type: feedback
----
+DIARIOS CON AUTOCRÍTICA:
+{diaries_json}
 
-{rule_content}
+FEEDBACKS POSTMORTEM QUE YA EXISTEN ({len(data['existing_feedbacks'])}):
+{json.dumps(data['existing_feedbacks'][:30], ensure_ascii=False)}
 
-**Why:** Pattern detected across multiple sessions where NEXO failed in this regard. The user should not have to correct the same thing twice.
+REGLAS PERMANENTES RECIENTES:
+{json.dumps(data['history_summary'].get('recent_rules', []), ensure_ascii=False)}
 
-**How to apply:** Verify this rule at the start of each session and before presenting work as complete.
+INSTRUCCIONES:
 
-**Evidence (original self-critiques):**
-"""
-    for i, critique in enumerate(source_critiques[:3], 1):
-        content += f"- Session {i}: {critique[:200]}\n"
+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)
+   - 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 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
+
+4. Para cada regla a promover, crea el archivo con 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
+   type: feedback
+   ---
+
+   [Descripción clara del patrón y la regla]
+
+   **Why:** [Por qué esto importa — con evidencia de las sesiones]
+   **How to apply:** [Cuándo y cómo aplicar esta regla]
+
+5. Escribe el resumen diario en ~/.nexo/coordination/postmortem-daily.md:
+   # Post-Mortem Daily — {data['date']}
+   Sesiones: X | Autocríticas: Y | Promovidos: Z
+
+   ## Autocríticas del día (resumen)
+   [Lista breve]
+
+   ## Promovido a memoria permanente
+   [Lo que promoviste y por qué]
 
-    filepath.write_text(content)
-    log(f"  Written permanent rule: {filename}")
-    return filename
+   ## Descartado (y por qué)
+   [Lo que NO promoviste y la razón]
 
+Ejecuta sin preguntar."""
+
+    log(f"Stage 2: Invoking Claude CLI (opus) with {len(diaries_with_critique)} critiques...")
+
+    env = os.environ.copy()
+    env.pop("CLAUDECODE", None)
+    env.pop("CLAUDE_CODE", None)
+
+    try:
+        result = subprocess.run(
+            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
+            capture_output=True, text=True, timeout=300, env=env
+        )
+
+        if result.returncode != 0:
+            log(f"Stage 2: CLI error (code {result.returncode}): {(result.stderr or '')[:300]}")
+            return False
+
+        log(f"Stage 2: Completed. Output: {len(result.stdout or '')} chars")
+        # Log last 500 chars of output for debugging
+        if result.stdout:
+            log(f"Stage 2 output tail: {result.stdout[-500:]}")
+        return True
+
+    except subprocess.TimeoutExpired:
+        log("Stage 2: CLI timed out (300s)")
+        return False
+    except Exception as e:
+        log(f"Stage 2: Exception: {e}")
+        return False
+
+
+# ─── Stage 3: Sensory Register + Force Analysis (pure Python) ───────────────
+# Kept from v1 — these are genuinely mechanical (embedding vectors, DB updates)
 
 def process_sensory_register():
-    """
-    Sensory Register — Atkinson-Shiffrin Layer 1.
-    Reads today's session_buffer events, embeds them, compares against LTM
-    to detect recurring patterns. Ingests meaningful events into STM as 'sensory'.
-    """
+    """Sensory Register — Atkinson-Shiffrin Layer 1. Embeds events into STM."""
     log("--- Sensory Register processing ---")
 
     if not SESSION_BUFFER.exists():
-        log("  No session_buffer.jsonl found, skipping sensory processing")
+        log("  No session_buffer.jsonl found, skipping")
         return
 
-    # Read today's events from session_buffer
     today_events = []
     try:
-        with open(SESSION_BUFFER, "r") as f:
+        with open(SESSION_BUFFER) as f:
             for line in f:
                 line = line.strip()
                 if not line:
                     continue
                 try:
                     event = json.loads(line)
-                    ts = event.get("ts", "")
-                    if ts.startswith(TODAY_STR):
+                    if event.get("ts", "").startswith(TODAY_STR):
                         today_events.append(event)
                 except json.JSONDecodeError:
                     continue
@@ -214,47 +237,33 @@ def process_sensory_register():
         return
 
     if not today_events:
-        log("  No events from today in session_buffer")
+        log("  No events from today")
         return
 
-    log(f"  Found {len(today_events)} events from today")
+    log(f"  Found {len(today_events)} events")
 
-    # Import cognitive engine
     try:
         import cognitive
     except ImportError as e:
-        log(f"  Cannot import cognitive engine: {e}")
+        log(f"  Cannot import cognitive: {e}")
         return
 
-    # Process events — only embed meaningful ones (not hook-fallback noise)
     ingested = 0
-    pattern_flags = []
-
     for event in today_events:
-        tasks = event.get("tasks", [])
-        decisions = event.get("decisions", [])
-        errors = event.get("errors_resolved", [])
-        user_patterns = event.get("user_patterns", [])
-        critique = event.get("self_critique", "")
         source = event.get("source", "")
-
-        # Skip empty hook-fallback events
-        if source == "hook-fallback" and not decisions and not errors and not user_patterns:
-            # Still embed if there are meaningful tasks (not just tool lists)
-            task_str = " ".join(tasks) if tasks else ""
-            if len(task_str) < 50 or "," in task_str:  # tool lists have commas
+        if source == "hook-fallback":
+            task_str = " ".join(event.get("tasks", []))
+            if len(task_str) < 50 or "," in task_str:
                 continue
 
-        # Build content for embedding
         parts = []
-        if tasks:
-            parts.append(f"Tasks: {'; '.join(tasks[:5])}")
-        if decisions:
-            parts.append(f"Decisions: {'; '.join(str(d) for d in decisions[:3])}")
-        if errors:
-            parts.append(f"Errors resolved: {'; '.join(str(e) for e in errors[:3])}")
-        if user_patterns:
-            parts.append(f"User patterns: {'; '.join(str(p) for p in user_patterns[:3])}")
+        for key, label in [("tasks", "Tasks"), ("decisions", "Decisions"),
+                           ("errors_resolved", "Errors"), ("the user_patterns", "user")]:
+            val = event.get(key, [])
+            if val:
+                parts.append(f"{label}: {'; '.join(str(v) for v in val[:3])}")
+
+        critique = event.get("self_critique", "")
         if critique and "hook-fallback" not in critique:
             parts.append(f"Self-critique: {critique[:200]}")
 
@@ -262,131 +271,42 @@ def process_sensory_register():
         if not content or len(content) < 20:
             continue
 
-        # Embed and check against LTM for patterns
         try:
             vec = cognitive.embed(content)
-            patterns = cognitive.detect_patterns(vec, threshold=0.65)
-
-            if patterns:
-                pattern_flags.append({
-                    "event_ts": event.get("ts", ""),
-                    "content": content[:200],
-                    "matches": patterns[:3],
-                })
-
-            # Ingest into STM as sensory
-            # Customize domain keywords for your own projects
             domain = ""
-            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"
+            lower = content.lower()
+            for keyword, dom in [("nexo", "nexo"),
+                                 ("default", "general")]:
+                if keyword in lower:
+                    domain = dom
+                    break
 
             cognitive.ingest_sensory(
-                content=content,
-                source_id=f"buffer#{event.get('ts', '')}",
-                domain=domain,
-                created_at=event.get("ts", "")
+                content=content, source_id=f"buffer#{event.get('ts', '')}",
+                domain=domain, created_at=event.get("ts", "")
             )
             ingested += 1
         except Exception as e:
-            log(f"  Error embedding event: {e}")
-            continue
+            log(f"  Error embedding: {e}")
 
     log(f"  Ingested {ingested} sensory events into STM")
 
-    # Report pattern matches (potential recurring behaviors)
-    if pattern_flags:
-        log(f"  PATTERN ALERT: {len(pattern_flags)} events matched existing LTM memories (potential repetitions)")
-        for pf in pattern_flags[:5]:
-            best = pf["matches"][0]
-            log(f"    [{best['score']:.2f}] Event: {pf['content'][:80]}...")
-            log(f"           Matches LTM {best['source_type']}: {best['content'][:80]}...")
-
-    # Archive: compress old events from buffer (>48h)
-    archive_sensory_buffer()
-
-    return {"ingested": ingested, "patterns": len(pattern_flags)}
-
-
-def archive_sensory_buffer():
-    """Move events older than 48h from session_buffer to daily archive files."""
-    if not SESSION_BUFFER.exists():
-        return
-
-    cutoff = (datetime.now() - timedelta(hours=48)).isoformat()
-    archive_dir = HOME / "claude" / "brain" / "session_archive"
-    archive_dir.mkdir(parents=True, exist_ok=True)
-
-    keep_lines = []
-    archived_by_day = {}
-
-    try:
-        with open(SESSION_BUFFER, "r") as f:
-            for line in f:
-                stripped = line.strip()
-                if not stripped:
-                    continue
-                try:
-                    event = json.loads(stripped)
-                    ts = event.get("ts", "")
-                    if ts < cutoff:
-                        day = ts[:10]
-                        archived_by_day.setdefault(day, []).append(stripped)
-                    else:
-                        keep_lines.append(stripped)
-                except json.JSONDecodeError:
-                    keep_lines.append(stripped)
-
-        # Write archived events to daily files
-        total_archived = 0
-        for day, lines in archived_by_day.items():
-            archive_file = archive_dir / f"{day}.jsonl"
-            with open(archive_file, "a") as f:
-                for line in lines:
-                    f.write(line + "\n")
-            total_archived += len(lines)
-
-        # Rewrite buffer with only recent events
-        if total_archived > 0:
-            with open(SESSION_BUFFER, "w") as f:
-                for line in keep_lines:
-                    f.write(line + "\n")
-            log(f"  Archived {total_archived} events (>48h) to session_archive/")
-        else:
-            log(f"  No events to archive (all within 48h)")
-
-    except Exception as e:
-        log(f"  Error archiving sensory buffer: {e}")
-
 
 def analyze_force_events():
-    """Analyze --force dissonance resolutions from today.
-
-    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?
-
-    If a --force exception targets the same memory multiple times → it's probably
-    a paradigm shift, not an exception. Flag for morning review.
-    """
+    """Analyze --force dissonance resolutions from today."""
     log("--- Force event analysis ---")
 
     try:
         import cognitive
     except ImportError:
-        log("  Cannot import cognitive engine, skipping")
+        log("  Cannot import cognitive, skipping")
         return
 
     db = cognitive._get_db()
     today_forces = db.execute(
-        """SELECT memory_id, context, created_at
-           FROM memory_corrections
-           WHERE correction_type = 'exception'
-             AND context LIKE '%[FORCE]%'
-             AND date(created_at) = ?
-           ORDER BY created_at""",
+        """SELECT memory_id, context, created_at FROM memory_corrections
+           WHERE correction_type = 'exception' AND context LIKE '%[FORCE]%'
+             AND date(created_at) = ? ORDER BY created_at""",
         (TODAY_STR,)
     ).fetchall()
 
@@ -394,201 +314,97 @@ def analyze_force_events():
         log("  No --force events today")
         return
 
-    log(f"  {len(today_forces)} --force events today")
+    log(f"  {len(today_forces)} --force events")
 
-    # Count how many times each memory was force-overridden
     from collections import Counter
     memory_counts = Counter(r["memory_id"] for r in today_forces)
-
     for mem_id, count in memory_counts.most_common():
         mem = db.execute(
-            "SELECT content, source_type, strength, domain FROM ltm_memories WHERE id = ?",
-            (mem_id,)
+            "SELECT content, strength FROM ltm_memories WHERE id = ?", (mem_id,)
         ).fetchone()
         if not mem:
             continue
 
-        # Check total force-overrides for this memory (all time)
-        total_overrides = db.execute(
+        total = db.execute(
             "SELECT COUNT(*) FROM memory_corrections WHERE memory_id = ? AND context LIKE '%[FORCE]%'",
             (mem_id,)
         ).fetchone()[0]
 
-        if total_overrides >= 3:
-            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
+        if total >= 3:
+            log(f"  PARADIGM SHIFT: LTM #{mem_id} overridden {total}x → decay to 0.3")
             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 = ?",
+                "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,)
             )
         elif count >= 2:
-            log(f"  WATCH: LTM #{mem_id} force-overridden {count}x today ({total_overrides}x total)")
-            log(f"    Content: {mem['content'][:120]}")
-        else:
-            log(f"  OK: LTM #{mem_id} force-overridden once (total: {total_overrides})")
+            log(f"  WATCH: LTM #{mem_id} overridden {count}x today")
 
     db.commit()
 
 
-def main():
-    log("=== NEXO Post-Mortem Consolidator starting ===")
-
-    diaries = get_today_diaries()
-    if not diaries:
-        log("No session diaries today. Nothing to consolidate.")
-        return
-
-    log(f"Found {len(diaries)} session diaries today.")
-
-    # Collect critiques and signals
-    today_critiques = []
-    correction_critiques = []
+# ─── Main ────────────────────────────────────────────────────────────────────
 
-    for d in diaries:
-        critique = d.get("self_critique") or ""
-        signals = d.get("user_signals") or ""
+def already_ran_today() -> bool:
+    """Prevent running twice on the same day."""
+    marker = HOME / ".nexo" / "coordination" / "postmortem-last-run"
+    if marker.exists():
+        try:
+            return marker.read_text().strip() == TODAY_STR
+        except Exception:
+            return False
+    return False
 
-        if critique and not critique.strip().lower().startswith("no self-critique"):
-            today_critiques.append(critique)
 
-        if has_correction_signals(signals):
-            correction_critiques.append({
-                "critique": critique,
-                "signals": signals,
-                "domain": d.get("domain", ""),
-            })
+def mark_done():
+    marker = HOME / ".nexo" / "coordination" / "postmortem-last-run"
+    marker.parent.mkdir(parents=True, exist_ok=True)
+    marker.write_text(TODAY_STR)
 
-    log(f"  {len(today_critiques)} non-trivial critiques, {len(correction_critiques)} with correction signals")
 
-    if not today_critiques and not correction_critiques:
-        log("All sessions clean. Nothing to consolidate.")
+def main():
+    if already_ran_today():
+        log("Already ran today. Skipping.")
         return
 
-    # Load history
-    history = load_history()
-
-    # Save today's rules to history
-    today_rules = extract_actionable_rules(today_critiques)
-    history["days"][TODAY_STR] = {
-        "rules": today_rules,
-        "corrections": len(correction_critiques),
-        "total_sessions": len(diaries),
-    }
+    log("=== NEXO Post-Mortem Consolidator v2 starting ===")
 
-    # Detect patterns that should become permanent
-    new_permanent = []
+    # Stage 1: Collect data
+    data = collect_data()
+    log(f"Stage 1: {len(data['diaries'])} diaries, {len(data['existing_feedbacks'])} existing feedbacks")
 
-    # Pattern 1: Same critique appears 2+ times TODAY
-    if len(today_rules) >= 2:
-        # Simple word-bag similarity between rules
-        for i, rule in enumerate(today_rules):
-            for j, other in enumerate(today_rules):
-                if i >= j:
-                    continue
-                words_i = set(rule.lower().split())
-                words_j = set(other.lower().split())
-                if words_i and words_j:
-                    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 on the same day:\n- {rule}\n- {other}",
-                            "sources": [rule, other],
-                        })
-
-    # Pattern 2: Rule appears across 3+ different days
-    all_historical_rules = []
-    for day_str, day_data in history["days"].items():
-        if day_str == TODAY_STR:
-            continue
-        for rule in day_data.get("rules", []):
-            all_historical_rules.append((day_str, rule))
-
-    for today_rule in today_rules:
-        matching_days = set()
-        today_words = set(today_rule.lower().split())
-        for hist_day, hist_rule in all_historical_rules:
-            hist_words = set(hist_rule.lower().split())
-            if today_words and hist_words:
-                overlap = len(today_words & hist_words) / min(len(today_words), len(hist_words))
-                if overlap > 0.4:
-                    matching_days.add(hist_day)
-
-        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 across {len(matching_days)+1} different days:\n- Today: {today_rule}\n- Previous days: {', '.join(sorted(matching_days)[:5])}",
-                "sources": [today_rule],
-            })
-
-    # Pattern 3: User corrected AND there's a critique → always promote
-    for cc in correction_critiques:
-        critique = cc.get("critique", "")
-        if critique and not rule_already_permanent(critique, history):
-            new_permanent.append({
-                "title": f"User correction: {critique[:50]}",
-                "content": f"The user explicitly corrected this behavior.\nSignals: {cc['signals'][:200]}\nSelf-critique: {critique[:300]}",
-                "sources": [critique],
-            })
-
-    # Write permanent rules
-    if new_permanent:
-        log(f"Promoting {len(new_permanent)} patterns to permanent memory:")
-        for rule in new_permanent:
-            filename = write_permanent_rule(rule["title"], rule["content"], rule["sources"])
-            if filename:
-                history.setdefault("permanent_rules", []).append(rule["title"])
-    else:
-        log("No patterns qualify for permanent promotion today.")
-
-    # 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)}",
-        "",
-    ]
-    if today_critiques:
-        summary_lines.append("## Today's self-critiques")
-        for c in today_critiques:
-            summary_lines.append(f"- {c[:200]}")
-        summary_lines.append("")
-    if new_permanent:
-        summary_lines.append("## Promoted to permanent memory")
-        for r in new_permanent:
-            summary_lines.append(f"- {r['title']}")
+    if not data["diaries"]:
+        log("No session diaries today. Nothing to consolidate.")
     else:
-        summary_lines.append("## Nothing promoted today")
-
-    summary_file.write_text("\n".join(summary_lines))
-    log(f"Written daily summary: {summary_file}")
-
-    save_history(history)
+        # Stage 2: CLI intelligence
+        success = consolidate_with_cli(data)
+        if not success:
+            log("Stage 2 failed — falling back to skip (no v1 fallback)")
 
-    # Phase 2: Sensory Register processing
+    # Stage 3: Sensory Register (mechanical, kept from v1)
     try:
         process_sensory_register()
     except Exception as e:
-        log(f"Sensory register processing failed: {e}")
+        log(f"Sensory register failed: {e}")
 
-    # Phase 3: Analyze --force dissonance events from today
+    # Stage 3b: Force analysis (mechanical, kept from v1)
     try:
         analyze_force_events()
     except Exception as e:
-        log(f"Force event analysis failed: {e}")
+        log(f"Force analysis failed: {e}")
 
-    # Register successful run for catch-up
+    # Register successful run
     try:
-        state_file = HOME / "claude" / "operations" / ".catchup-state.json"
+        state_file = HOME / ".nexo" / "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))
     except Exception:
         pass
 
-    log("=== Consolidation complete ===")
+    mark_done()
+    log("=== Consolidation v2 complete ===")
 
 
 if __name__ == "__main__":