nexo-brain 1.7.0 → 2.1.0

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

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Deep Sleep v2 -- Phase 3: Synthesize extractions into actionable findings.
+
+One Claude call that reads all per-session extractions and produces a
+unified synthesis with cross-session patterns, morning agenda, context
+packets, and deduplicated actions.
+
+Environment variables:
+  NEXO_HOME  -- root of the NEXO installation (default: ~/.nexo)
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
+PROMPT_FILE = Path(__file__).parent / "synthesize-prompt.md"
+
+CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
+
+
+def find_claude_cli() -> str:
+    """Find the Claude CLI binary."""
+    candidates = [
+        Path.home() / ".local" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]
+    for c in candidates:
+        if c.exists():
+            return str(c)
+    which = shutil.which("claude")
+    if which:
+        return which
+    return "claude"
+
+
+def extract_json_from_response(text: str) -> dict | None:
+    """Parse JSON from Claude's response, handling markdown fences."""
+    text = text.strip()
+
+    if text.startswith("```"):
+        lines = text.split("\n")
+        end = len(lines)
+        for i in range(len(lines) - 1, 0, -1):
+            if lines[i].strip() == "```":
+                end = i
+                break
+        text = "\n".join(lines[1:end]).strip()
+
+    brace_start = text.find("{")
+    if brace_start < 0:
+        return None
+
+    depth = 0
+    for i in range(brace_start, len(text)):
+        if text[i] == "{":
+            depth += 1
+        elif text[i] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[brace_start:i + 1])
+                except json.JSONDecodeError:
+                    break
+    return None
+
+
+def main():
+    target_date = sys.argv[1] if len(sys.argv) > 1 else datetime.now().strftime("%Y-%m-%d")
+
+    extractions_file = DEEP_SLEEP_DIR / f"{target_date}-extractions.json"
+    context_file = DEEP_SLEEP_DIR / f"{target_date}-context.txt"
+
+    if not extractions_file.exists():
+        print(f"[synthesize] No extractions file for {target_date}. Run extract.py first.")
+        sys.exit(1)
+
+    # Check if there are any findings worth synthesizing
+    with open(extractions_file) as f:
+        extractions = json.load(f)
+
+    total_findings = extractions.get("total_findings", 0)
+    if total_findings == 0:
+        print(f"[synthesize] No findings to synthesize for {target_date}.")
+        # Write minimal synthesis
+        output = {
+            "date": target_date,
+            "sessions_analyzed": extractions.get("sessions_analyzed", 0),
+            "cross_session_patterns": [],
+            "morning_agenda": [],
+            "context_packets": [],
+            "actions": [],
+            "summary": f"No significant findings for {target_date}."
+        }
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(output, f, indent=2, ensure_ascii=False)
+        print(f"[synthesize] Output: {output_file}")
+        return
+
+    # Build prompt
+    prompt_template = PROMPT_FILE.read_text()
+    prompt = prompt_template.replace("{{EXTRACTIONS_FILE}}", str(extractions_file))
+    prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
+
+    claude_bin = find_claude_cli()
+    print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
+    print(f"[synthesize] Claude CLI: {claude_bin}")
+
+    try:
+        env = os.environ.copy()
+        env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
+
+        result = subprocess.run(
+            [
+                claude_bin,
+                "-p", prompt,
+                "--model", "opus",
+                "--output-format", "text",
+                "--allowedTools",
+                "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__nexo_startup,mcp__nexo__nexo_learning_search,mcp__nexo__nexo_recall,mcp__nexo__nexo_reminders"
+            ],
+            capture_output=True,
+            text=True,
+            timeout=CLAUDE_TIMEOUT,
+            env=env
+        )
+
+        if result.returncode != 0:
+            print(f"[synthesize] Claude CLI error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
+            sys.exit(1)
+
+        # Filter hook contamination
+        output_text = "\n".join(
+            l for l in result.stdout.strip().splitlines()
+            if not l.strip().startswith("Post-mortem")
+        )
+        parsed = extract_json_from_response(output_text)
+
+        # Fallback: Opus might have written the file directly via Write tool
+        if not parsed:
+            for candidate in [
+                DEEP_SLEEP_DIR / f"{target_date}-analysis.json",
+                DEEP_SLEEP_DIR / f"{target_date}-synthesis.json",
+            ]:
+                if candidate.exists() and candidate.stat().st_size > 100:
+                    try:
+                        parsed = json.load(open(candidate))
+                        print(f"[synthesize] Opus wrote file directly: {candidate}")
+                        break
+                    except Exception:
+                        continue
+
+        if not parsed:
+            debug_file = DEEP_SLEEP_DIR / f"debug-synthesize-{target_date}.txt"
+            debug_file.write_text(result.stdout[:10000])
+            print(f"[synthesize] Failed to parse JSON. Raw output saved to {debug_file}", file=sys.stderr)
+            sys.exit(1)
+
+        # Write synthesis output
+        output_file = DEEP_SLEEP_DIR / f"{target_date}-synthesis.json"
+        with open(output_file, "w") as f:
+            json.dump(parsed, f, indent=2, ensure_ascii=False)
+
+        n_actions = len(parsed.get("actions", []))
+        n_patterns = len(parsed.get("cross_session_patterns", []))
+        n_agenda = len(parsed.get("morning_agenda", []))
+        n_packets = len(parsed.get("context_packets", []))
+
+        print(f"[synthesize] Done.")
+        print(f"  Actions: {n_actions}")
+        print(f"  Cross-session patterns: {n_patterns}")
+        print(f"  Morning agenda items: {n_agenda}")
+        print(f"  Context packets: {n_packets}")
+        print(f"[synthesize] Output: {output_file}")
+
+    except subprocess.TimeoutExpired:
+        print(f"[synthesize] Claude CLI timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        print(f"[synthesize] Claude CLI not found at: {claude_bin}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -1,213 +1,6 @@
 #!/usr/bin/env python3
-"""
-NEXO Auto-Update — checks for new versions and applies updates.
-
-Runs at boot via the catch-up system or manually.
-Compares local version with the latest GitHub release.
-If a new version is available, downloads and applies the update.
-"""
-
-import json
-import os
-import shutil
-import subprocess
+"""DEPRECATED: Updates are handled automatically by NEXO on startup."""
 import sys
-from datetime import datetime
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-VERSION_FILE = NEXO_HOME / "version.json"
-LOG_FILE = NEXO_HOME / "logs" / "auto-update.log"
-REPO = "wazionapps/nexo"
-
-
-def log(msg: str):
-    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 get_local_version() -> str:
-    """Read locally installed version."""
-    if VERSION_FILE.exists():
-        try:
-            return json.loads(VERSION_FILE.read_text()).get("version", "0.0.0")
-        except Exception:
-            pass
-    return "0.0.0"
-
-
-def get_remote_version() -> dict | None:
-    """Check latest release on GitHub."""
-    try:
-        result = subprocess.run(
-            ["gh", "api", f"repos/{REPO}/releases/latest"],
-            capture_output=True, text=True, timeout=15
-        )
-        if result.returncode == 0:
-            data = json.loads(result.stdout)
-            return {
-                "version": data.get("tag_name", "").lstrip("v"),
-                "tarball_url": data.get("tarball_url", ""),
-                "published_at": data.get("published_at", ""),
-                "body": data.get("body", "")[:500],
-            }
-    except Exception:
-        pass
-    return None
-
-
-def version_compare(local: str, remote: str) -> int:
-    """Compare semver strings. Returns -1 (local older), 0 (same), 1 (local newer)."""
-    def parse(v):
-        parts = v.split(".")
-        return tuple(int(p) for p in parts if p.isdigit())
-
-    l, r = parse(local), parse(remote)
-    if l < r:
-        return -1
-    elif l > r:
-        return 1
-    return 0
-
-
-def apply_update(tarball_url: str, new_version: str) -> bool:
-    """Download and apply update from GitHub release tarball."""
-    import tempfile
-
-    log(f"Downloading update v{new_version}...")
-    tmp_dir = Path(tempfile.mkdtemp(prefix="nexo-update-"))
-
-    try:
-        # Download tarball
-        tarball = tmp_dir / "release.tar.gz"
-        result = subprocess.run(
-            ["curl", "-sL", "-o", str(tarball), tarball_url],
-            capture_output=True, timeout=60
-        )
-        if result.returncode != 0:
-            log(f"Download failed: {result.stderr}")
-            return False
-
-        # Extract
-        subprocess.run(
-            ["tar", "xzf", str(tarball), "-C", str(tmp_dir)],
-            capture_output=True, timeout=30
-        )
-
-        # Find extracted directory (GitHub tarballs have a top-level dir)
-        extracted = [d for d in tmp_dir.iterdir() if d.is_dir()]
-        if not extracted:
-            log("No directory found in tarball")
-            return False
-
-        src_dir = extracted[0] / "src"
-        if not src_dir.exists():
-            log("No src/ directory in release")
-            return False
-
-        # Backup current files
-        backup_dir = NEXO_HOME / "backups" / f"pre-update-{new_version}"
-        backup_dir.mkdir(parents=True, exist_ok=True)
-
-        files_updated = 0
-        # Update core Python files
-        for py_file in src_dir.glob("*.py"):
-            dest = NEXO_HOME / py_file.name
-            if dest.exists():
-                shutil.copy2(dest, backup_dir / py_file.name)
-            shutil.copy2(py_file, dest)
-            files_updated += 1
-
-        # Update plugins
-        plugins_src = src_dir / "plugins"
-        if plugins_src.exists():
-            plugins_dest = NEXO_HOME / "plugins"
-            plugins_dest.mkdir(exist_ok=True)
-            for py_file in plugins_src.glob("*.py"):
-                dest = plugins_dest / py_file.name
-                if dest.exists():
-                    shutil.copy2(dest, backup_dir / f"plugin_{py_file.name}")
-                shutil.copy2(py_file, dest)
-                files_updated += 1
-
-        # Update scripts
-        scripts_src = src_dir / "scripts"
-        if scripts_src.exists():
-            scripts_dest = NEXO_HOME / "scripts"
-            scripts_dest.mkdir(exist_ok=True)
-            for py_file in scripts_src.glob("*.py"):
-                dest = scripts_dest / py_file.name
-                if dest.exists():
-                    shutil.copy2(dest, backup_dir / f"script_{py_file.name}")
-                shutil.copy2(py_file, dest)
-                files_updated += 1
-
-        # Update hooks
-        hooks_src = src_dir / "hooks"
-        if hooks_src.exists():
-            hooks_dest = NEXO_HOME / "hooks"
-            hooks_dest.mkdir(exist_ok=True)
-            for sh_file in hooks_src.glob("*.sh"):
-                dest = hooks_dest / sh_file.name
-                shutil.copy2(sh_file, dest)
-                os.chmod(dest, 0o755)
-                files_updated += 1
-
-        # Save new version
-        VERSION_FILE.write_text(json.dumps({
-            "version": new_version,
-            "updated_at": datetime.now().isoformat(),
-            "files_updated": files_updated,
-            "backup": str(backup_dir),
-        }, indent=2))
-
-        log(f"Update applied: {files_updated} files updated. Backup at {backup_dir}")
-        return True
-
-    except Exception as e:
-        log(f"Update failed: {e}")
-        return False
-    finally:
-        shutil.rmtree(tmp_dir, ignore_errors=True)
-
-
-def main():
-    log("=== NEXO Auto-Update check ===")
-
-    local_ver = get_local_version()
-    log(f"Local version: {local_ver}")
-
-    remote = get_remote_version()
-    if not remote:
-        log("Could not check remote version (no network or no releases)")
-        return
-
-    remote_ver = remote["version"]
-    log(f"Remote version: {remote_ver}")
-
-    cmp = version_compare(local_ver, remote_ver)
-    if cmp >= 0:
-        log("Already up to date.")
-        return
-
-    log(f"Update available: {local_ver} → {remote_ver}")
-    log(f"Release notes: {remote['body'][:200]}")
-
-    if remote["tarball_url"]:
-        success = apply_update(remote["tarball_url"], remote_ver)
-        if success:
-            log(f"Successfully updated to v{remote_ver}")
-        else:
-            log("Update failed — will retry next boot")
-    else:
-        log("No tarball URL in release — manual update needed")
-
-    log("=== Done ===")
-
-
-if __name__ == "__main__":
-    main()
+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.sh

@@ -1,20 +1,12 @@
 #!/bin/bash
-# NEXO DB hourly backup
-# Install: crontab -e → 0 * * * * /path/to/nexo-backup.sh
-#
-# Keeps hourly backups for 48h and weekly backups for 90 days.
-
-NEXO_DIR="${NEXO_DIR:-$(dirname "$(dirname "$(realpath "$0")")")}"
-BACKUP_DIR="$NEXO_DIR/backups"
+# 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_DIR/db/nexo.db"
+DB="$NEXO_HOME/data/nexo.db"
 RETENTION_HOURS=48
 
-if [ ! -f "$DB" ]; then
-    echo "ERROR: nexo.db not found at $DB" >&2
-    exit 1
-fi
-
 mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
 
 # Hourly backup

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

@@ -1,7 +1,7 @@
 #!/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.
+# 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
 
@@ -9,12 +9,12 @@ BRAIN_DIR="~/.nexo/brain"
 MODEL_FILE="$BRAIN_DIR/user_model.json"
 SUMMARIES_DIR="$BRAIN_DIR/daily_summaries"
 
-# --- Guardia: archivo imprescindible ---
+# --- Guard: required file ---
 if [[ ! -f "$MODEL_FILE" ]]; then
     exit 0
 fi
 
-# --- Python inline para parsear JSON y analizar ---
+# --- Inline Python to parse JSON and analyze ---
 python3 - <<'PYEOF'
 import json
 import sys
@@ -26,7 +26,7 @@ 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 ──────────────────────────────────────────────────────────
+# ── Load model ──────────────────────────────────────────────────────────
 try:
     with open(MODEL_FILE) as f:
         model = json.load(f)
@@ -35,11 +35,11 @@ except Exception:
 
 insights = []
 
-# ── 1. Analizar evolution_log — últimas 3-5 entradas ─────────────────────
+# ── 1. Analyze evolution_log — last 3-5 entries ─────────────────────
 evolution = model.get("evolution_log", [])
 recent = evolution[-5:] if len(evolution) >= 5 else evolution
 
-# Detectar entradas de los últimos 3 días
+# Detect entries from the last 3 days
 today = datetime.now().date()
 cutoff = today - timedelta(days=3)
 
@@ -56,9 +56,9 @@ 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í.
+# ── 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:
@@ -66,13 +66,13 @@ if traits:
     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
+    # Only report if extreme (>0.9 or <0.2) to avoid noise
     if dominant_val >= 0.9:
-        insights.append(f"Trait dominante: {dominant}={dominant_val} (máximo registrado)")
+        insights.append(f"Dominant trait: {dominant}={dominant_val} (highest recorded)")
     if weakest_val <= 0.2:
-        insights.append(f"Trait en mínimo: {weakest}={weakest_val} (baja tolerancia activa)")
+        insights.append(f"Lowest trait: {weakest}={weakest_val} (low tolerance active)")
 
-# ── 3. Contradicciones recientes (últimos 3 días) ─────────────────────────
+# ── 3. Recent contradictions (last 3 days) ─────────────────────────
 contradictions = model.get("contradictions", [])
 recent_contradictions = []
 for c in contradictions:
@@ -84,24 +84,24 @@ for c in contradictions:
         pass
 
 for c in recent_contradictions:
-    insights.append(f"Contradicción detectada: {c['description'].strip()}")
+    insights.append(f"Contradiction detected: {c['description'].strip()}")
 
-# ── 4. Foco activo actual ─────────────────────────────────────────────────
+# ── 4. Current active focus ─────────────────────────────────────────────────
 current_focus = model.get("current_focus", [])
-# Solo incluir si hay focos (y no es el arranque inicial)
+# Only include if there are focus items (and it's not initial startup)
 if len(current_focus) > 0 and len(insights) == 0:
-    # Si no hay otros insights, reportar foco como contexto mínimo
+    # If no other insights, report focus as minimum context
     focus_str = ", ".join(current_focus)
-    insights.append(f"Foco actual: {focus_str}")
+    insights.append(f"Current focus: {focus_str}")
 
-# ── 5. Goals: cambios active/dormant ─────────────────────────────────────
+# ── 5. Goals: active/dormant changes ─────────────────────────────────────
 goals_active = model.get("goals_active", [])
 goals_dormant = model.get("goals_dormant", [])
-# Si hay goals dormant, mencionarlos (pueden necesitar reactivación)
+# If there are dormant goals, mention them (may need reactivation)
 if goals_dormant:
     insights.append(f"Goal dormant: {goals_dormant[0]}")
 
-# ── Leer último daily summary ─────────────────────────────────────────────
+# ── Read last daily summary ─────────────────────────────────────────────
 summary_text = ""
 try:
     files = sorted(glob.glob(os.path.join(SUMMARIES_DIR, "*.md")))
@@ -109,17 +109,17 @@ try:
         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")]
+        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 ────────────────────────────────────────────────────────────────
-# Si no hay insights reales, salir sin output
+# If no real insights, exit without output
 if not insights and not summary_text:
     sys.exit(0)
 
-# Deduplicar y limitar
+# Deduplicate and limit
 seen = set()
 unique_insights = []
 for ins in insights:

package/src/scripts/nexo-catchup.py

@@ -27,15 +27,32 @@ from pathlib import Path
 CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
 
 HOME = Path.home()
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 LOG_FILE = LOG_DIR / "catchup.log"
 STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
 
-PYTHON_BREW = "/opt/homebrew/bin/python3"
-PYTHON_SYS = "/Library/Frameworks/Python.framework/Versions/3.12/bin/python3"
 SCRIPTS = NEXO_HOME / "scripts"
 
+# Resolve Python: prefer NEXO's venv, then the same Python running this script
+def _resolve_python() -> str:
+    """Find the best Python to use for subprocess calls."""
+    # Check for NEXO_CODE env var pointing to the repo's src/
+    nexo_code = os.environ.get("NEXO_CODE", "")
+    if nexo_code:
+        venv_python = Path(nexo_code).parent / ".venv" / "bin" / "python"
+        if venv_python.exists():
+            return str(venv_python)
+    # Check for venv relative to NEXO_HOME
+    venv_python = NEXO_HOME / ".venv" / "bin" / "python"
+    if venv_python.exists():
+        return str(venv_python)
+    # Fall back to the same Python running this script
+    return sys.executable
+
+NEXO_PYTHON = _resolve_python()
+
 
 def log(msg: str):
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -108,7 +125,7 @@ def run_task(name: str, python: str, script: str, state: dict) -> bool:
     try:
         result = subprocess.run(
             [python, script_path],
-            capture_output=True, text=True, timeout=300,
+            capture_output=True, text=True, timeout=21600,
             env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
         )
         if result.returncode == 0:
@@ -133,27 +150,15 @@ def main():
     state = load_state()
 
     # Define tasks in execution order (matching their intended schedule order)
-    # Auto-update check FIRST
-    update_script = SCRIPTS / "nexo-auto-update.py"
-    if update_script.exists():
-        log("Checking for NEXO updates...")
-        try:
-            subprocess.run(
-                [PYTHON_BREW if os.path.exists(PYTHON_BREW) else PYTHON_SYS, str(update_script)],
-                capture_output=True, text=True, timeout=60,
-                env={**os.environ, "HOME": str(HOME), "NEXO_HOME": str(NEXO_HOME / "nexo-mcp")}
-            )
-        except Exception as e:
-            log(f"  Update check failed: {e}")
-
+    # Note: auto-update is handled by the MCP server on startup, not by catchup.
     tasks = [
         # (name, hour, minute, python, script, weekday)
-        ("cognitive-decay", 3, 0, PYTHON_BREW, "nexo-cognitive-decay.py", None),
-        ("evolution", 3, 0, PYTHON_SYS, "nexo-evolution-run.py", 6),  # Sunday = 6
-        ("sleep", 4, 0, PYTHON_SYS, "nexo-sleep.py", None),
-        ("self-audit", 7, 0, PYTHON_SYS, "nexo-daily-self-audit.py", None),
-        ("github-monitor", 8, 0, PYTHON_BREW, "nexo-github-monitor.py", None),
-        ("postmortem", 23, 30, PYTHON_BREW, "nexo-postmortem-consolidator.py", None),
+        ("cognitive-decay", 3, 0, NEXO_PYTHON, "nexo-cognitive-decay.py", None),
+        ("evolution", 3, 0, NEXO_PYTHON, "nexo-evolution-run.py", 6),  # Sunday = 6
+        ("sleep", 4, 0, NEXO_PYTHON, "nexo-sleep.py", None),
+        ("self-audit", 7, 0, NEXO_PYTHON, "nexo-daily-self-audit.py", None),
+        ("github-monitor", 8, 0, NEXO_PYTHON, "nexo-github-monitor.py", None),
+        ("postmortem", 23, 30, NEXO_PYTHON, "nexo-postmortem-consolidator.py", None),
     ]
 
     ran = 0
@@ -182,6 +187,11 @@ def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):
     if not CLAUDE_CLI.exists():
         log(f"Caught up {ran} tasks, {skipped} already current. (CLI unavailable for assessment)")
         return
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] Claude CLI not authenticated. Skipping CLI analysis.")
+        return
 
     assessment_file = LOG_DIR / "catchup-assessment.md"
     state_summary = json.dumps(state, indent=2, default=str)
@@ -208,14 +218,15 @@ Format:
 
     log(f"Caught up {ran} tasks — running CLI assessment...")
     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",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=90, env=env
+            [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:
             log(f"Assessment written to {assessment_file}")