nexo-brain 1.5.1 → 1.5.3

package/README.md

@@ -130,10 +130,22 @@ Like a human brain, NEXO Brain has automated processes that run while you're not
 |------|---------|---------------|
 | 03:00 | Decay + memory consolidation + merge duplicates + dreaming | Deep sleep consolidation |
 | 04:00 | Clean expired data, prune redundant memories | Synaptic pruning |
+| 04:30 | **Deep Sleep** — analyze full session transcripts for uncaptured corrections, protocol violations, missed commitments | REM sleep review |
 | 07:00 | Self-audit, health checks, metrics | Waking up + orientation |
 | 23:30 | Process day's events, extract patterns | Pre-sleep reflection |
 | Boot | Catch-up: run anything missed while computer was off | -- |
 
+#### Deep Sleep (v1.5.2)
+
+Deep Sleep reads your **complete session transcripts** (not just the diary summary) and finds what the agent missed during the day:
+
+- **Uncaptured corrections** — user corrections the agent didn't save as learnings
+- **Protocol violations** — guard_check skipped, trust not adjusted, change_log omitted
+- **Missed commitments** — things mentioned but never tracked as followups
+- **Quality issues** — agent declaring "done" when work wasn't complete
+
+Uses Claude CLI in `--bare` mode (no hooks, no CLAUDE.md interference). Catch-up system re-runs yesterday if the Mac was off.
+
 If your Mac was asleep during any scheduled process, NEXO Brain catches up in order when it wakes.
 
 ## Cognitive Cortex

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO — Cognitive co-operator for Claude Code. Atkinson-Shiffrin memory, semantic RAG, knowledge graph, HNSW vector indexing, trust scoring, and metacognitive error prevention.",
   "bin": {

package/src/scripts/deep-sleep/apply_findings.py

@@ -79,6 +79,44 @@ def adjust_trust(points: int, context: str):
         pass
 
 
+def add_learning(category: str, title: str, content: str) -> bool:
+    """Add a learning to nexo.db using real schema."""
+    if not NEXO_DB.exists():
+        return False
+    try:
+        now = datetime.now().timestamp()
+        conn = sqlite3.connect(str(NEXO_DB))
+        conn.execute(
+            "INSERT INTO learnings (category, title, content, created_at, updated_at, reasoning) VALUES (?, ?, ?, ?, ?, ?)",
+            (category, title, content, now, now, "Deep Sleep overnight analysis")
+        )
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"  Error adding learning: {e}", file=sys.stderr)
+        return False
+
+
+def add_followup(followup_id: str, description: str, date: str = None) -> bool:
+    """Add a followup to nexo.db using real schema."""
+    if not NEXO_DB.exists():
+        return False
+    try:
+        now = datetime.now().timestamp()
+        conn = sqlite3.connect(str(NEXO_DB))
+        conn.execute(
+            "INSERT OR IGNORE INTO followups (id, description, date, status, created_at, updated_at, reasoning) VALUES (?, ?, ?, 'PENDIENTE', ?, ?, ?)",
+            (followup_id, description, date or "", now, now, "Deep Sleep overnight analysis")
+        )
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"  Error adding followup: {e}", file=sys.stderr)
+        return False
+
+
 def apply(analysis: dict):
     """Apply all findings from deep sleep analysis."""
     memory_dir = find_memory_dir()
@@ -88,32 +126,44 @@ def apply(analysis: dict):
 
     print(f"\nApplying findings for {date}...")
 
-    # 1. Uncaptured corrections → feedback memories (high/critical only)
+    # 1. Uncaptured corrections → learnings + feedback memories
     for i, correction in enumerate(analysis.get("uncaptured_corrections", [])):
         severity = correction.get("severity", "medium")
-        if severity not in ("high", "critical"):
-            continue
-
         category = correction.get("category", "process")
         content = correction.get("what_nexo_should_have_saved", "")
         quote = correction.get("quote", "")
 
-        safe_name = category.replace(" ", "_").lower()
-        filename = f"ds_{date}_{safe_name}_{i}.md"
-        write_feedback_memory(
-            memory_dir, filename,
-            name=content[:60],
-            description=f"Deep sleep detected uncaptured correction ({severity})",
-            content=f"{content}\n\n**Why:** User said: \"{quote}\"\nContext: {correction.get('context', '')}\n\n**How to apply:** {content}"
-        )
-        memory_entries.append({
-            "title": content[:40],
-            "filename": filename,
-            "summary": f"Deep sleep {date}, severity {severity}"
-        })
-        actions_taken.append(f"feedback_write: {filename}")
-
-    # 2. Trust adjustments for critical violations
+        # All corrections → learnings
+        learning_title = f"[Deep Sleep] {content[:80]}"
+        learning_content = f"User said: \"{quote}\"\nContext: {correction.get('context', '')}\nRepeated: {correction.get('times_repeated', 1)} times"
+        if add_learning(category, learning_title, learning_content):
+            actions_taken.append(f"learning_add: {learning_title[:50]}")
+
+        # High/critical → also feedback memories
+        if severity in ("high", "critical"):
+            safe_name = category.replace(" ", "_").lower()
+            filename = f"ds_{date}_{safe_name}_{i}.md"
+            write_feedback_memory(
+                memory_dir, filename,
+                name=content[:60],
+                description=f"Deep sleep detected uncaptured correction ({severity})",
+                content=f"{content}\n\n**Why:** User said: \"{quote}\"\nContext: {correction.get('context', '')}\n\n**How to apply:** {content}"
+            )
+            memory_entries.append({
+                "title": content[:40],
+                "filename": filename,
+                "summary": f"Deep sleep {date}, severity {severity}"
+            })
+            actions_taken.append(f"feedback_write: {filename}")
+
+    # 2. Missed commitments → followups
+    for i, commitment in enumerate(analysis.get("missed_commitments", [])):
+        fid = f"NF-DS-{date}-{i}"
+        desc = f"[Deep Sleep] {commitment.get('commitment', '')[:100]}"
+        if add_followup(fid, desc, commitment.get("due_date")):
+            actions_taken.append(f"followup: {desc[:50]}")
+
+    # 3. Trust adjustments for critical violations
     critical_violations = [v for v in analysis.get("protocol_violations", []) if v.get("severity") == "critical"]
     if critical_violations:
         points = -3 * len(critical_violations)

package/src/scripts/nexo-deep-sleep.sh

@@ -1,14 +1,13 @@
 #!/bin/bash
-# NEXO Deep Sleep — Complete overnight session transcript analysis
-# Reads ALL Claude Code session transcripts from the day, analyzes with
-# Claude CLI (bare mode), and applies findings as feedback memories.
+# NEXO Deep Sleep — Complete overnight session analysis
+# Runs at 4:30 AM via LaunchAgent
+# Reads ALL session transcripts from the day, analyzes with Claude CLI,
+# and applies findings (learnings, feedbacks, followups, trust adjustments)
 #
 # Features:
 # - Catch-up: if yesterday was missed (Mac off/asleep), runs it first
-# - Uses --bare mode to avoid loading NEXO hooks during analysis
-# - Requires ANTHROPIC_API_KEY env var or ~/.claude/anthropic-api-key.txt
-#
-# Install: Add as LaunchAgent for daily execution (recommended: 4:30 AM)
+# - Logs to ~/claude/logs/deep-sleep.log
+# - Marks completion in .last-run for watchdog monitoring
 
 set -euo pipefail
 
@@ -26,9 +25,11 @@ run_analysis() {
     local DATE="$1"
     log "=== Deep Sleep starting for $DATE ==="
 
+    # Step 1: Collect transcripts
     log "Step 1: Collecting transcripts for $DATE..."
     python3 "$SCRIPT_DIR/deep-sleep/collect_transcripts.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
+    # Check if transcripts were found
     if [ ! -f "$DEEP_SLEEP_DIR/$DATE-transcripts.json" ]; then
         log "No transcripts file generated for $DATE. Skipping."
         return 0
@@ -40,6 +41,7 @@ run_analysis() {
         return 0
     fi
 
+    # Step 2: Analyze with Claude CLI
     log "Step 2: Analyzing $SESSIONS sessions with Claude CLI..."
     python3 "$SCRIPT_DIR/deep-sleep/analyze_session.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
@@ -48,6 +50,7 @@ run_analysis() {
         return 1
     fi
 
+    # Step 3: Apply findings
     log "Step 3: Applying findings for $DATE..."
     python3 "$SCRIPT_DIR/deep-sleep/apply_findings.py" "$DATE" 2>&1 | tee -a "$LOG_DIR/deep-sleep.log"
 
@@ -55,22 +58,24 @@ run_analysis() {
     return 0
 }
 
-# --- Catch-up: check if yesterday was missed ---
+# --- Catch-up: check if the day before yesterday was missed ---
 YESTERDAY=$(date -v-1d +%Y-%m-%d 2>/dev/null || date -d "yesterday" +%Y-%m-%d 2>/dev/null)
+DAY_BEFORE=$(date -v-2d +%Y-%m-%d 2>/dev/null || date -d "2 days ago" +%Y-%m-%d 2>/dev/null)
 LAST_RUN=""
 if [ -f "$LAST_RUN_FILE" ]; then
     LAST_RUN=$(cat "$LAST_RUN_FILE")
 fi
 
-if [ -n "$YESTERDAY" ] && [ "$LAST_RUN" != "$YESTERDAY" ] && [ "$LAST_RUN" != "$TODAY" ]; then
-    if [ ! -f "$DEEP_SLEEP_DIR/$YESTERDAY-analysis.json" ]; then
-        log "*** CATCH-UP: $YESTERDAY was missed. Running now. ***"
-        run_analysis "$YESTERDAY" || log "Catch-up for $YESTERDAY failed."
+if [ -n "$DAY_BEFORE" ] && [ "$LAST_RUN" != "$DAY_BEFORE" ] && [ "$LAST_RUN" != "$YESTERDAY" ]; then
+    # Day before yesterday wasn't analyzed — catch up
+    if [ ! -f "$DEEP_SLEEP_DIR/$DAY_BEFORE-analysis.json" ]; then
+        log "*** CATCH-UP: $DAY_BEFORE was missed. Running now. ***"
+        run_analysis "$DAY_BEFORE" || log "Catch-up for $DAY_BEFORE failed."
     fi
 fi
 
-# --- Run today's analysis ---
-run_analysis "$TODAY"
+# --- Run yesterday's analysis (main task — at 4:30 AM, today has no sessions yet) ---
+run_analysis "$YESTERDAY"
 
-# Mark completion
-echo "$TODAY" > "$LAST_RUN_FILE"
+# Mark completion with yesterday's date (what we actually analyzed)
+echo "$YESTERDAY" > "$LAST_RUN_FILE"