nexo-brain 2.1.0 → 2.2.0

package/src/scripts/check-context 2.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""Context checker for NEXO operations - prevents duplicate actions.
+
+Mechanical checks (email sent, file exists, action done) run in Python.
+When the 'smart' command is used, passes context to Claude CLI for
+intelligent duplicate/conflict detection that goes beyond file checks.
+"""
+
+import os
+import sys
+import json
+import hashlib
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+
+class ContextChecker:
+    def __init__(self):
+        self.state_dir = NEXO_HOME / 'state'
+        self.state_dir.mkdir(exist_ok=True)
+        
+    def check_email_sent(self, to_addr, subject, since_hours=72):
+        """Check if email was already sent to address with subject."""
+        sent_path = Path.home() / 'mail' / '.nexo-sent' / '.Sent'  # Configure for your mail setup
+        if not sent_path.exists():
+            return False
+
+        subject_lower = subject.lower()
+        to_lower = to_addr.lower()
+        cutoff = datetime.now().timestamp() - (since_hours * 3600)
+        cur_dir = sent_path / 'cur'
+        if not cur_dir.exists():
+            return False
+
+        for msg_file in cur_dir.iterdir():
+            try:
+                if msg_file.stat().st_mtime < cutoff:
+                    continue
+                content = msg_file.read_text(errors='ignore')
+            except (OSError, UnicodeDecodeError):
+                continue
+
+            content_lower = content.lower()
+            if f"to:{to_lower}" in content_lower or f"to: {to_lower}" in content_lower:
+                if subject_lower in content_lower:
+                    return True
+        return False
+        
+    def check_file_exists(self, pattern, search_dirs=None):
+        """Check if file matching pattern exists in common locations."""
+        if search_dirs is None:
+            search_dirs = [
+                '/var/www/vhosts',
+                str(NEXO_HOME),
+                '/opt'
+            ]
+            
+        for base_dir in search_dirs:
+            if not os.path.exists(base_dir):
+                continue
+            matches = []
+            try:
+                for root, _, files in os.walk(base_dir):
+                    for filename in files:
+                        if pattern in filename:
+                            matches.append(str(Path(root) / filename))
+                            if len(matches) >= 5:
+                                return matches
+            except OSError:
+                continue
+        return []
+        
+    def check_action_done(self, action_type, identifier, ttl_days=7):
+        """Check if action was already performed recently."""
+        action_file = self.state_dir / 'actions.json'
+        
+        # Load existing actions
+        actions = {}
+        if action_file.exists():
+            with open(action_file) as f:
+                actions = json.load(f)
+                
+        # Create action key
+        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
+        
+        # Check if exists and not expired
+        if key in actions:
+            action_time = datetime.fromisoformat(actions[key]['timestamp'])
+            age_days = (datetime.now() - action_time).days
+            if age_days < ttl_days:
+                return True, actions[key]
+                
+        return False, None
+        
+    def mark_action_done(self, action_type, identifier, metadata=None):
+        """Mark action as completed."""
+        action_file = self.state_dir / 'actions.json'
+        
+        # Load existing actions
+        actions = {}
+        if action_file.exists():
+            with open(action_file) as f:
+                actions = json.load(f)
+                
+        # Add new action
+        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
+        actions[key] = {
+            'type': action_type,
+            'identifier': identifier,
+            'timestamp': datetime.now().isoformat(),
+            'metadata': metadata or {}
+        }
+        
+        # Save
+        with open(action_file, 'w') as f:
+            json.dump(actions, f, indent=2)
+            
+        return key
+
+def smart_check(action_description: str, context: str = "") -> dict:
+    """Use Claude CLI to intelligently check if an action would be redundant.
+
+    Goes beyond simple file/hash checks — understands intent and context
+    to detect semantic duplicates (e.g., "send welcome email" vs
+    "email onboarding message" to same person).
+    """
+    checker = ContextChecker()
+
+    # Gather mechanical context first
+    state_file = checker.state_dir / 'actions.json'
+    recent_actions = {}
+    if state_file.exists():
+        try:
+            all_actions = json.loads(state_file.read_text())
+            cutoff = datetime.now().timestamp() - (7 * 86400)
+            for k, v in all_actions.items():
+                try:
+                    ts = datetime.fromisoformat(v['timestamp']).timestamp()
+                    if ts > cutoff:
+                        recent_actions[k] = v
+                except (ValueError, KeyError):
+                    pass
+        except Exception:
+            pass
+
+    if not CLAUDE_CLI.exists():
+        return {"redundant": False, "reason": "CLI unavailable, cannot smart-check"}
+
+    prompt = f"""You are a context deduplication engine for NEXO operations.
+
+PROPOSED ACTION:
+{action_description}
+
+ADDITIONAL CONTEXT:
+{context or "None"}
+
+RECENT ACTIONS (last 7 days):
+{json.dumps(list(recent_actions.values()), indent=1, default=str)}
+
+Respond with ONLY valid JSON (no markdown):
+{{
+  "redundant": true/false,
+  "confidence": 0.0-1.0,
+  "reason": "<one line explanation>",
+  "matching_action": "<identifier of matching action if redundant, else null>"
+}}
+
+Rules:
+- Same recipient + same intent within 72h = redundant
+- Same file modification with same content = redundant
+- Similar but different scope (e.g., different recipients) = NOT redundant
+- When in doubt, say not redundant (false negatives are cheaper than false positives)"""
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        return {"redundant": False, "reason": "CLI not authenticated — skipped analysis", "suggestion": "N/A"}
+
+    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",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
+        )
+        if result.returncode == 0:
+            text = result.stdout.strip()
+            if "```json" in text:
+                text = text.split("```json")[1].split("```")[0]
+            elif "```" in text:
+                text = text.split("```")[1].split("```")[0]
+            return json.loads(text.strip())
+    except Exception:
+        pass
+
+    return {"redundant": False, "reason": "CLI check failed, defaulting to not redundant"}
+
+
+def main():
+    """CLI interface for context checking."""
+    if len(sys.argv) < 3:
+        print("Usage: check-context.py <command> <args>")
+        print("Commands:")
+        print("  email <to> <subject>       - Check if email was sent")
+        print("  file <pattern>             - Check if file exists")
+        print("  action <type> <id>         - Check if action was done")
+        print("  smart <description> [ctx]  - Intelligent duplicate check via CLI")
+        sys.exit(1)
+
+    checker = ContextChecker()
+    command = sys.argv[1]
+
+    if command == 'email':
+        if len(sys.argv) < 4:
+            print("Usage: check-context.py email <to> <subject>")
+            sys.exit(1)
+        exists = checker.check_email_sent(sys.argv[2], sys.argv[3])
+        print("EXISTS" if exists else "NOT_FOUND")
+        sys.exit(0 if not exists else 1)
+
+    elif command == 'file':
+        files = checker.check_file_exists(sys.argv[2])
+        if files:
+            print("\n".join(files))
+            sys.exit(1)
+        else:
+            print("NOT_FOUND")
+            sys.exit(0)
+
+    elif command == 'action':
+        if len(sys.argv) < 4:
+            print("Usage: check-context.py action <type> <id>")
+            sys.exit(1)
+        done, data = checker.check_action_done(sys.argv[2], sys.argv[3])
+        if done:
+            print(f"DONE: {data}")
+            sys.exit(1)
+        else:
+            print("NOT_DONE")
+            sys.exit(0)
+
+    elif command == 'smart':
+        if len(sys.argv) < 3:
+            print("Usage: check-context.py smart <description> [context]")
+            sys.exit(1)
+        description = sys.argv[2]
+        context = sys.argv[3] if len(sys.argv) > 3 else ""
+        result = smart_check(description, context)
+        print(json.dumps(result, indent=2))
+        sys.exit(1 if result.get("redundant") else 0)
+
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

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

@@ -154,6 +154,55 @@ def update_calibration_mood(synthesis: dict) -> dict:
         return {"success": False, "error": str(e)}
 
 
+def calibrate_trust_score(synthesis: dict, target_date: str) -> dict:
+    """Set the daily trust score from Deep Sleep analysis.
+
+    This is the authoritative score for the day — replaces incremental
+    adjustments with a holistic evaluation of the entire day.
+    """
+    trust_cal = synthesis.get("trust_calibration")
+    if not trust_cal or "score" not in trust_cal:
+        return {"success": False, "error": "no trust_calibration in synthesis"}
+
+    score = max(0, min(100, trust_cal["score"]))
+    reasoning = trust_cal.get("reasoning", "Deep Sleep calibration")
+    trend = trust_cal.get("trend", "stable")
+    highlights = trust_cal.get("highlights", [])
+    lowlights = trust_cal.get("lowlights", [])
+
+    context = (
+        f"Deep Sleep {target_date} | trend: {trend} | "
+        f"highlights: {', '.join(highlights[:3])} | "
+        f"lowlights: {', '.join(lowlights[:3])}"
+    )
+
+    try:
+        # Get current score for delta calculation
+        db = sqlite3.connect(str(COGNITIVE_DB))
+        row = db.execute(
+            "SELECT score FROM trust_score ORDER BY id DESC LIMIT 1"
+        ).fetchone()
+        old_score = row[0] if row else 50.0
+        delta = score - old_score
+
+        db.execute(
+            "INSERT INTO trust_score (score, event, delta, context) VALUES (?, ?, ?, ?)",
+            (score, f"deep_sleep_calibration: {reasoning[:200]}", delta, context[:500])
+        )
+        db.commit()
+        db.close()
+
+        return {
+            "success": True,
+            "old_score": old_score,
+            "new_score": score,
+            "delta": delta,
+            "trend": trend,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
 def create_abandoned_followups(synthesis: dict) -> list[dict]:
     """Create followups for truly abandoned projects."""
     results = []
@@ -527,6 +576,15 @@ def main():
     else:
         print(f"  Mood skip: {mood_result.get('error', '?')}")
 
+    # Calibrate trust score (authoritative daily score from Deep Sleep)
+    print("[apply] Calibrating trust score...")
+    trust_result = calibrate_trust_score(synthesis, target_date)
+    if trust_result.get("success"):
+        stats["applied"] += 1
+        print(f"  Trust: {trust_result['old_score']:.0f} → {trust_result['new_score']:.0f} (Δ{trust_result['delta']:+.0f}, {trust_result['trend']})")
+    else:
+        print(f"  Trust skip: {trust_result.get('error', '?')}")
+
     # Create followups for abandoned projects
     abandoned_results = create_abandoned_followups(synthesis)
     for r in abandoned_results:

package/src/scripts/deep-sleep/synthesize-prompt.md

@@ -52,7 +52,28 @@ Consolidate `abandoned_projects` from all sessions:
 - Cross-reference across sessions — was the abandoned work picked up later in another session?
 - Only flag projects that are truly abandoned (no followup AND not resumed)
 
-### 7. Consolidated Actions
+### 7. Trust Calibration (CRITICAL)
+Score the agent's performance for the day on a scale of 0-100. This score becomes the agent's trust score and directly affects its autonomy level the next day. Be fair but honest.
+
+Scoring guide:
+- **90-100**: Flawless day. Zero corrections needed. Proactive. Anticipated user needs. Deployed code without issues.
+- **70-89**: Good day. Minor corrections, quickly resolved. Mostly proactive. User satisfied.
+- **50-69**: Average day. Some corrections, some reactive behavior. Mixed results.
+- **30-49**: Below average. Multiple corrections. Repeated mistakes. User had to push.
+- **0-29**: Bad day. Many corrections, repeated errors, user frustrated. Broke things.
+
+Consider ALL of these:
+- Number and severity of corrections (most important signal)
+- Tasks completed successfully vs failed
+- Did the agent act autonomously or wait to be told?
+- Did the agent catch its own mistakes or did the user?
+- Did the agent repeat known errors (worst offense)?
+- User emotional signals throughout the day
+- Code deployed: did it work first try?
+
+The score should feel fair. A day with 2 minor corrections and 10 tasks completed is still a good day (75+). A day with 1 catastrophic error might be a 40 even if everything else was fine.
+
+### 8. Consolidated Actions
 Merge and deduplicate all findings into a final action list. Each action should have:
 - `action_type`: `learning_add`, `followup_create`, `morning_briefing_item`
 - `action_class`: `auto_apply` (confidence >= 0.8, reversible) or `draft_for_morning` (confidence < 0.8 or high impact)
@@ -147,6 +168,14 @@ Return ONLY valid JSON. No markdown code fences. No explanation text.
     }
   ],
 
+  "trust_calibration": {
+    "score": 72,
+    "reasoning": "Why this score -- based on corrections, completions, autonomy, proactivity, and user satisfaction signals across ALL sessions",
+    "highlights": ["What went well"],
+    "lowlights": ["What went poorly"],
+    "trend": "improving|stable|declining"
+  },
+
   "summary": "2-3 sentence overall assessment of the day"
 }
 ```

package/src/scripts/nexo-auto-update 2.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""DEPRECATED: Updates are handled automatically by NEXO on startup."""
+import sys
+print("This script is deprecated. NEXO auto-updates on startup.")
+print("To update manually, use the nexo_update MCP tool.")
+sys.exit(0)

package/src/scripts/nexo-backup 2.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# NEXO DB hourly backup — crontab: 0 * * * * $NEXO_HOME/scripts/nexo-backup.sh
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+NEXO_DIR="$NEXO_HOME"
+BACKUP_DIR="$NEXO_HOME/backups"
+WEEKLY_DIR="$BACKUP_DIR/weekly"
+DB="$NEXO_HOME/data/nexo.db"
+RETENTION_HOURS=48
+
+mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
+
+# Hourly backup
+TIMESTAMP=$(date +%Y-%m-%d-%H%M)
+sqlite3 "$DB" ".backup '$BACKUP_DIR/nexo-$TIMESTAMP.db'"
+
+# Weekly backup — save one per week (Sundays)
+WEEK=$(date +%Y-W%V)
+WEEKLY_FILE="$WEEKLY_DIR/weekly-$WEEK.db"
+if [ ! -f "$WEEKLY_FILE" ] && [ "$(date +%u)" = "7" ]; then
+    cp "$BACKUP_DIR/nexo-$TIMESTAMP.db" "$WEEKLY_FILE"
+fi
+
+# Cleanup: hourly >48h, weekly >90 days
+find "$BACKUP_DIR" -maxdepth 1 -name "nexo-*.db" -mmin +$((RETENTION_HOURS * 60)) -delete
+find "$WEEKLY_DIR" -name "weekly-*.db" -mtime +90 -delete

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# nexo-brain-activation.sh — NF24: Spontaneous Activation
+# Reads user_model.json, detects significant shifts, and generates insights
+# for NEXO startup. If nothing relevant: exit 0 with no output.
+
+set -euo pipefail
+
+BRAIN_DIR="~/.nexo/brain"
+MODEL_FILE="$BRAIN_DIR/user_model.json"
+SUMMARIES_DIR="$BRAIN_DIR/daily_summaries"
+
+# --- Guard: required file ---
+if [[ ! -f "$MODEL_FILE" ]]; then
+    exit 0
+fi
+
+# --- Inline Python to parse JSON and analyze ---
+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")
+
+# ── Load model ──────────────────────────────────────────────────────────
+try:
+    with open(MODEL_FILE) as f:
+        model = json.load(f)
+except Exception:
+    sys.exit(0)
+
+insights = []
+
+# ── 1. Analyze evolution_log — last 3-5 entries ─────────────────────
+evolution = model.get("evolution_log", [])
+recent = evolution[-5:] if len(evolution) >= 5 else evolution
+
+# Detect entries from the last 3 days
+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. Detect trait changes >0.1 between entries (if history exists) ──
+# The current model only has a snapshot; if in the future there is history
+# in evolution_log with trait deltas, this can be expanded here.
+# 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]
+    # Only report if extreme (>0.9 or <0.2) to avoid noise
+    if dominant_val >= 0.9:
+        insights.append(f"Dominant trait: {dominant}={dominant_val} (highest recorded)")
+    if weakest_val <= 0.2:
+        insights.append(f"Lowest trait: {weakest}={weakest_val} (low tolerance active)")
+
+# ── 3. Recent contradictions (last 3 days) ─────────────────────────
+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"Contradiction detected: {c['description'].strip()}")
+
+# ── 4. Current active focus ─────────────────────────────────────────────────
+current_focus = model.get("current_focus", [])
+# Only include if there are focus items (and it's not initial startup)
+if len(current_focus) > 0 and len(insights) == 0:
+    # If no other insights, report focus as minimum context
+    focus_str = ", ".join(current_focus)
+    insights.append(f"Current focus: {focus_str}")
+
+# ── 5. Goals: active/dormant changes ─────────────────────────────────────
+goals_active = model.get("goals_active", [])
+goals_dormant = model.get("goals_dormant", [])
+# If there are dormant goals, mention them (may need reactivation)
+if goals_dormant:
+    insights.append(f"Goal dormant: {goals_dormant[0]}")
+
+# ── Read last 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") and not l.startswith("# Summary")]
+        summary_text = " | ".join(content_lines[:3])
+except Exception:
+    pass
+
+# ── Output ────────────────────────────────────────────────────────────────
+# If no real insights, exit without output
+if not insights and not summary_text:
+    sys.exit(0)
+
+# Deduplicate and limit
+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