nexo-brain 1.7.0 → 2.1.0

package/src/scripts/nexo-install.py

@@ -1,227 +1,6 @@
 #!/usr/bin/env python3
-"""NEXO Install — First-time setup for NEXO Brain.
-
-Creates ~/.nexo/ directory structure, initializes databases,
-copies scripts/hooks/plugins from the repo, and sets NEXO_HOME
-in the user's shell profile.
-
-Usage:
-    python3 nexo-install.py              # interactive install
-    python3 nexo-install.py --yes        # skip confirmations
-    python3 nexo-install.py --nexo-home /path  # custom location
-"""
-
-import argparse
-import json
-import os
-import shutil
-import subprocess
+"""DEPRECATED: Use 'npx nexo-brain' instead. This installer is no longer maintained."""
 import sys
-from datetime import datetime
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent  # nexo/src/scripts -> nexo/
-
-# Required directory structure
-NEXO_DIRS = [
-    "db",
-    "brain",
-    "logs",
-    "operations",
-    "coordination",
-    "scripts",
-    "hooks",
-    "plugins",
-    "backups",
-    "memory",
-    "docs",
-    "projects",
-    "learnings",
-    "agents",
-    "skills",
-]
-
-
-def get_version() -> str:
-    """Read version from package.json."""
-    pkg = REPO_ROOT / "package.json"
-    if not pkg.exists():
-        return "0.0.0"
-    return json.loads(pkg.read_text()).get("version", "0.0.0")
-
-
-def detect_shell() -> tuple[str, Path]:
-    """Detect user's shell and return (shell_name, profile_path)."""
-    shell = os.environ.get("SHELL", "/bin/bash")
-    home = Path.home()
-
-    if "zsh" in shell:
-        return "zsh", home / ".zshrc"
-    elif "fish" in shell:
-        return "fish", home / ".config" / "fish" / "config.fish"
-    else:
-        # bash — prefer .bashrc, fall back to .bash_profile
-        bashrc = home / ".bashrc"
-        if bashrc.exists():
-            return "bash", bashrc
-        return "bash", home / ".bash_profile"
-
-
-def create_directory_structure(nexo_home: Path):
-    """Create all required directories."""
-    for d in NEXO_DIRS:
-        (nexo_home / d).mkdir(parents=True, exist_ok=True)
-    print(f"  Created {len(NEXO_DIRS)} directories in {nexo_home}")
-
-
-def initialize_databases(nexo_home: Path):
-    """Initialize empty databases with schema."""
-    os.environ["NEXO_HOME"] = str(nexo_home)
-    os.environ["NEXO_SKIP_FS_INDEX"] = "1"
-
-    src_dir = REPO_ROOT / "src"
-    if str(src_dir) not in sys.path:
-        sys.path.insert(0, str(src_dir))
-
-    try:
-        from db import init_db
-        init_db()
-        print("  Initialized nexo.db with schema.")
-    except Exception as e:
-        print(f"  WARNING: DB init error: {e}", file=sys.stderr)
-        print("  You can run schema migrations later with nexo-migrate.py")
-
-
-def copy_repo_files(nexo_home: Path):
-    """Copy hooks, scripts, and plugins from the repo."""
-    src = REPO_ROOT / "src"
-
-    # Copy scripts
-    scripts_src = src / "scripts"
-    scripts_dst = nexo_home / "scripts"
-    if scripts_src.exists():
-        count = 0
-        for f in scripts_src.iterdir():
-            if f.is_file() and not f.name.startswith("__"):
-                shutil.copy2(f, scripts_dst / f.name)
-                count += 1
-        print(f"  Copied {count} scripts.")
-
-    # Copy plugins
-    plugins_src = src / "plugins"
-    plugins_dst = nexo_home / "plugins"
-    if plugins_src.exists():
-        count = 0
-        for f in plugins_src.iterdir():
-            if f.is_file() and f.suffix == ".py" and not f.name.startswith("__"):
-                shutil.copy2(f, plugins_dst / f.name)
-                count += 1
-        print(f"  Copied {count} plugins.")
-
-    # Copy hooks (templates directory)
-    hooks_src = REPO_ROOT / "templates" / "hooks"
-    hooks_dst = nexo_home / "hooks"
-    if hooks_src.exists():
-        count = 0
-        for f in hooks_src.iterdir():
-            if f.is_file():
-                shutil.copy2(f, hooks_dst / f.name)
-                count += 1
-        if count:
-            print(f"  Copied {count} hooks.")
-
-
-def set_nexo_home_env(nexo_home: Path, shell_name: str, profile_path: Path):
-    """Add NEXO_HOME export to shell profile if not already present."""
-    export_line = f'export NEXO_HOME="{nexo_home}"'
-
-    if profile_path.exists():
-        content = profile_path.read_text()
-        if "NEXO_HOME" in content:
-            print(f"  NEXO_HOME already set in {profile_path}")
-            return
-    else:
-        content = ""
-
-    with open(profile_path, "a") as f:
-        f.write(f"\n# NEXO Brain — cognitive co-operator\n")
-        f.write(f"{export_line}\n")
-
-    print(f"  Added NEXO_HOME to {profile_path}")
-
-
-def write_version_json(nexo_home: Path, version: str):
-    """Write version.json."""
-    data = {
-        "version": version,
-        "installed_at": datetime.now().isoformat(timespec="seconds"),
-        "nexo_home": str(nexo_home),
-    }
-    (nexo_home / "version.json").write_text(json.dumps(data, indent=2) + "\n")
-    print(f"  Written version.json (v{version})")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="NEXO Brain — First-time setup")
-    parser.add_argument("--yes", "-y", action="store_true", help="Skip confirmations")
-    parser.add_argument("--nexo-home", type=str, default=None, help="Custom NEXO_HOME path")
-    args = parser.parse_args()
-
-    nexo_home = Path(args.nexo_home) if args.nexo_home else Path.home() / ".nexo"
-    version = get_version()
-    shell_name, profile_path = detect_shell()
-
-    print(f"NEXO Brain Installer v{version}")
-    print(f"=" * 40)
-    print(f"  NEXO_HOME: {nexo_home}")
-    print(f"  Shell:     {shell_name} ({profile_path})")
-    print(f"  Version:   {version}")
-    print()
-
-    if nexo_home.exists() and (nexo_home / "version.json").exists():
-        existing = json.loads((nexo_home / "version.json").read_text())
-        print(f"  Existing installation found: v{existing.get('version', '?')}")
-        print(f"  Use nexo-migrate.py to upgrade instead.")
-        if not args.yes:
-            resp = input("  Continue anyway? (y/N) ")
-            if resp.lower() != "y":
-                print("Aborted.")
-                return
-
-    if not args.yes:
-        resp = input("Install NEXO Brain? (Y/n) ")
-        if resp.lower() == "n":
-            print("Aborted.")
-            return
-
-    print()
-    print("Installing...")
-
-    # Step 1: Create directories
-    create_directory_structure(nexo_home)
-
-    # Step 2: Initialize databases
-    initialize_databases(nexo_home)
-
-    # Step 3: Copy files from repo
-    copy_repo_files(nexo_home)
-
-    # Step 4: Set NEXO_HOME in shell profile
-    set_nexo_home_env(nexo_home, shell_name, profile_path)
-
-    # Step 5: Write version.json
-    write_version_json(nexo_home, version)
-
-    print()
-    print("=" * 40)
-    print("NEXO Brain installed successfully!")
-    print()
-    print("Next steps:")
-    print(f"  1. Restart your shell or run: source {profile_path}")
-    print(f"  2. Add the NEXO MCP server to your Claude Code config:")
-    print(f"     claude mcp add nexo -- python3 {REPO_ROOT / 'src' / 'server.py'}")
-    print(f"  3. Start a Claude Code session — NEXO will initialize automatically.")
-
-
-if __name__ == "__main__":
-    main()
+print("This installer is deprecated. Please use: npx nexo-brain")
+print("See: https://github.com/wazionapps/nexo#installation")
+sys.exit(1)

package/src/scripts/nexo-learning-housekeep.py

@@ -1,4 +1,3 @@
-import os
 #!/usr/bin/env python3
 """NEXO Learning Housekeeping — Nightly dedup, weight adjustment, and review.
 
@@ -7,6 +6,7 @@ detects duplicates via semantic similarity, and archives stale learnings.
 """
 
 import json
+import os
 import sqlite3
 import sys
 import time
@@ -14,10 +14,14 @@ from datetime import datetime, timedelta
 from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
 
-sys.path.insert(0, str(NEXO_HOME / "nexo-mcp"))
+sys.path.insert(0, str(NEXO_CODE))
 
-DB_PATH = NEXO_HOME / "nexo-mcp" / "db" / "nexo.db"
+DB_PATH = NEXO_HOME / "data" / "nexo.db"
 STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
 
 # Weight adjustment rates

package/src/scripts/nexo-learning-validator.py

@@ -30,7 +30,7 @@ from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
-NEXO_DB = Path.home() / ".nexo" / "nexo.db"
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
 
 
@@ -111,27 +111,6 @@ Rules:
 
     # Try CLI first, fall back to mechanical similarity
     if CLAUDE_CLI.exists():
-        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=60, env=env
-            )
-            if result.returncode == 0:
-                text = result.stdout.strip()
-                # Strip markdown fences if present
-                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 (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
-            pass  # Fall through to mechanical fallback
-
     # Fallback: mechanical SequenceMatcher (original logic)
     return _mechanical_validate(finding, learnings)
 

package/src/scripts/nexo-migrate.py

@@ -73,10 +73,16 @@ def backup_databases() -> str:
     backup_dir = NEXO_HOME / "backups" / f"pre-migrate-{ts}"
     backup_dir.mkdir(parents=True, exist_ok=True)
 
-    db_dir = NEXO_HOME / "db"
-    if db_dir.exists():
-        for db_file in db_dir.glob("*.db*"):
+    data_dir = NEXO_HOME / "data"
+    if data_dir.exists():
+        for db_file in data_dir.glob("*.db*"):
             shutil.copy2(db_file, backup_dir / db_file.name)
+    # Also check legacy db/ location
+    legacy_db_dir = NEXO_HOME / "db"
+    if legacy_db_dir.exists():
+        for db_file in legacy_db_dir.glob("*.db*"):
+            if not (backup_dir / db_file.name).exists():
+                shutil.copy2(db_file, backup_dir / db_file.name)
 
     # Also backup version.json
     vfile = NEXO_HOME / "version.json"

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

@@ -29,10 +29,14 @@ from pathlib import Path
 HOME = Path.home()
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
 
-# Add nexo-mcp to path for cognitive engine (Stage 3)
-sys.path.insert(0, str(NEXO_HOME))
-
-NEXO_DB = NEXO_HOME / "db" / "nexo.db"
+# Add NEXO_HOME to path for cognitive engine (Stage 3)
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+sys.path.insert(0, str(NEXO_CODE))
+
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 # Memory directory — adjust to match your project's memory location
 MEMORY_DIR = NEXO_HOME / "memory"
 MEMORY_INDEX = MEMORY_DIR / "MEMORY.md"
@@ -109,7 +113,7 @@ def consolidate_with_cli(data: dict) -> bool:
 
     diaries_with_critique = [
         d for d in data["diaries"]
-        if d.get("self_critique") and not (d["self_critique"] or "").strip().lower().startswith("no self-critique")
+        if d.get("self_critique") and not str(d["self_critique"]).strip().lower().startswith("no self-critique")
     ]
 
     if not diaries_with_critique:
@@ -121,8 +125,10 @@ def consolidate_with_cli(data: dict) -> bool:
     if len(diaries_json) > 12000:
         diaries_json = diaries_json[:12000] + "\n... (truncated)"
 
-    prompt = f"""You are NEXO's nightly consolidator. Your job is to review the self-critiques
-from today and decide which deserve to become permanent rules (feedback_postmortem_*.md).
+    prompt = f"""FIRST: Call nexo_startup(task='nightly postmortem consolidation') to register this session.
+
+You are NEXO's nightly consolidator. Your job is to review the self-critiques
+from today and decide which deserve to become permanent rules. Use nexo_learning_add for permanent rules and nexo_followup_create for action items.
 
 DATE: {data['date']}
 SESSIONS TODAY: {len(data['diaries'])} total, {len(diaries_with_critique)} with self-critique
@@ -181,16 +187,17 @@ INSTRUCTIONS:
 Execute without asking."""
 
     log(f"Stage 2: Invoking Claude CLI (opus) with {len(diaries_with_critique)} critiques...")
-
     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=300, env=env
+             "--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:

package/src/scripts/nexo-pre-commit.py

@@ -4,12 +4,14 @@ NEXO Pre-Commit Validator — Dynamic version
 Queries nexo.db learnings to surface relevant warnings/blockers before commit.
 Runs standalone (no MCP dependency, just sqlite3).
 """
+import os
 import sqlite3
 import subprocess
 import sys
 from pathlib import Path
 
-NEXO_DB = Path.home() / ".nexo" / "nexo-mcp" / "db" / "nexo.db"
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 
 
 def get_staged_files():

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

@@ -0,0 +1,29 @@
+#!/bin/bash
+# NEXO Prevent Sleep — keeps the machine awake so nocturnal processes run.
+#
+# macOS: uses caffeinate -s -i (prevent system + idle sleep)
+# Linux: uses systemd-inhibit or caffeine if available, otherwise no-op
+#
+# Run as LaunchAgent (KeepAlive) or systemd service.
+
+case "$(uname -s)" in
+    Darwin)
+        exec caffeinate -s -i -w $$
+        ;;
+    Linux)
+        if command -v systemd-inhibit &>/dev/null; then
+            exec systemd-inhibit --what=idle:sleep --who=nexo --why="NEXO nocturnal processes" sleep infinity
+        elif command -v caffeine &>/dev/null; then
+            exec caffeine
+        else
+            echo "[NEXO] No sleep prevention tool found. Install systemd-inhibit or caffeine."
+            echo "[NEXO] Nocturnal processes may not run if the system sleeps."
+            # Keep running so launchd/systemd doesn't restart loop
+            exec sleep infinity
+        fi
+        ;;
+    *)
+        echo "[NEXO] Unsupported platform: $(uname -s)"
+        exit 1
+        ;;
+esac

package/src/scripts/nexo-proactive-dashboard.py

@@ -21,7 +21,7 @@ from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
-NEXO_DB = NEXO_HOME / "nexo-mcp" / "db" / "nexo.db"
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 
 
 def get_db():
@@ -38,6 +38,7 @@ def check_overdue_followups() -> list[dict]:
         SELECT id, description, date, created_at, reasoning
         FROM followups
         WHERE status NOT LIKE 'COMPLETED%'
+        AND status NOT IN ('DELETED','archived','blocked','waiting')
         AND date IS NOT NULL AND date != ''
         ORDER BY date ASC
     """).fetchall()
@@ -151,7 +152,7 @@ def check_session_gaps() -> list[dict]:
 def check_evolution_status() -> list[dict]:
     """Check if evolution system is healthy."""
     alerts = []
-    obj_file = NEXO_HOME / "cortex" / "evolution-objective.json"
+    obj_file = NEXO_HOME / "brain" / "evolution-objective.json"
     if obj_file.exists():
         obj = json.loads(obj_file.read_text())
         if not obj.get("evolution_enabled", True):
@@ -219,7 +220,7 @@ def check_recurring_errors() -> list[dict]:
         alerts.append({
             "type": "recurring_errors",
             "severity": "medium",
-            "title": f"Categoria '{r['category']}' tiene {r['cnt']} learnings this week — possible systemic issue",
+            "title": f"Category '{r['category']}' has {r['cnt']} learnings this week — possible systemic issue",
             "category": r["category"],
             "count": r["cnt"],
         })
@@ -231,7 +232,7 @@ def check_cron_health() -> list[dict]:
     alerts = []
 
     # Check backup cron
-    backup_dir = NEXO_HOME / "nexo-mcp" / "backups"
+    backup_dir = NEXO_HOME / "backups"
     if backup_dir.exists():
         backups = sorted(backup_dir.glob("nexo-*.db"), key=lambda p: p.stat().st_mtime, reverse=True)
         if backups:

package/src/scripts/nexo-runtime-preflight.py

@@ -4,13 +4,14 @@ NEXO Runtime Preflight
 
 Runs safe end-to-end smoke tests for Cortex and Evolution using a temporary
 workspace and a copied SQLite database. No external API calls are performed.
-Results are written to ~/.nexo/logs/runtime-preflight-summary.json.
+Results are written to NEXO_HOME/logs/runtime-preflight-summary.json.
 """
 
 from __future__ import annotations
 
 import importlib.util
 import json
+import os
 import shutil
 import sqlite3
 import sys
@@ -20,13 +21,25 @@ from datetime import datetime
 from pathlib import Path
 
 HOME = Path.home()
-CLAUDE_DIR = HOME / ".nexo"
-LOG_DIR = CLAUDE_DIR / "logs"
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+
+LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 SUMMARY_FILE = LOG_DIR / "runtime-preflight-summary.json"
-DB_FILE = CLAUDE_DIR / "nexo-mcp" / "db" / "nexo.db"
-CORTEX_OBJECTIVE = CLAUDE_DIR / "cortex" / "evolution-objective.json"
-CORTEX_PROMPT = CLAUDE_DIR / "cortex" / "evolution-prompt.md"
+DB_FILE = NEXO_HOME / "data" / "nexo.db"
+# Evolution config: NEXO_HOME/brain/ (canonical), NEXO_HOME/cortex/ (legacy fallback), NEXO_CODE (dev fallback)
+def _find_evolution_file(name: str) -> Path:
+    for candidate in [NEXO_HOME / "brain" / name, NEXO_HOME / "cortex" / name, NEXO_CODE / name]:
+        if candidate.exists():
+            return candidate
+    return NEXO_HOME / "brain" / name  # default canonical path
+
+CORTEX_OBJECTIVE = _find_evolution_file("evolution-objective.json")
+CORTEX_PROMPT = _find_evolution_file("evolution-prompt.md")
 
 
 def _load_module(name: str, path: Path):
@@ -143,7 +156,7 @@ def main() -> int:
         temp_db = temp_root / "nexo.db"
         shutil.copy2(DB_FILE, temp_db)
 
-        temp_cortex_dir = temp_root / "cortex"
+        temp_cortex_dir = temp_root / "brain"
         temp_logs_dir = temp_root / "logs"
         temp_coord_dir = temp_root / "coordination"
         temp_daily_dir = temp_root / "daily_summaries"
@@ -159,18 +172,23 @@ def main() -> int:
 
         temp_objective = temp_cortex_dir / "evolution-objective.json"
         temp_prompt = temp_cortex_dir / "evolution-prompt.md"
-        shutil.copy2(CORTEX_OBJECTIVE, temp_objective)
+        if CORTEX_OBJECTIVE.exists():
+            shutil.copy2(CORTEX_OBJECTIVE, temp_objective)
+        else:
+            # Create a minimal objective so evolution smoke tests can proceed
+            temp_objective.write_text(json.dumps({"evolution_enabled": True, "dimensions": {}}, indent=2))
         if CORTEX_PROMPT.exists():
             shutil.copy2(CORTEX_PROMPT, temp_prompt)
-        shutil.copy2(CLAUDE_DIR / "scripts" / "nexo-snapshot-restore.sh", temp_scripts_dir / "nexo-snapshot-restore.sh")
+        snapshot_restore = NEXO_CODE / "scripts" / "nexo-snapshot-restore.sh"
+        if snapshot_restore.exists():
+            shutil.copy2(snapshot_restore, temp_scripts_dir / "nexo-snapshot-restore.sh")
 
         temp_api_key = temp_root / "anthropic-api-key.txt"
         temp_api_key.write_text("smoke-test-key")
 
-        evolution_cycle = _load_module("evolution_cycle", CLAUDE_DIR / "cortex" / "evolution_cycle.py")
+        evolution_cycle = _load_module("evolution_cycle", NEXO_CODE / "evolution_cycle.py")
         evolution_cycle.NEXO_DB = temp_db
-        evolution_cycle.CLAUDE_DIR = temp_root
-        evolution_cycle.CORTEX_DIR = temp_cortex_dir
+        evolution_cycle.NEXO_HOME = temp_root
         evolution_cycle.SANDBOX_DIR = temp_sandbox_dir
         evolution_cycle.SNAPSHOTS_DIR = temp_snapshots_dir
         evolution_cycle.OBJECTIVE_FILE = temp_objective
@@ -189,7 +207,7 @@ def main() -> int:
             "restore_ok": restore_ok,
         }
 
-        cortex = _load_module("cortex_wrapper", CLAUDE_DIR / "cortex" / "cortex-wrapper.py")
+        cortex = _load_module("cortex_plugin", NEXO_CODE / "plugins" / "cortex.py")
         cortex.NEXO_DB = temp_db
         cortex.DRY_RUN = True
         cortex.BRIEFING_FILE = temp_cortex_dir / "briefing.json"
@@ -209,50 +227,36 @@ def main() -> int:
         cortex._check_health_endpoints = lambda: []
         cortex._call_anthropic = lambda prompt, model=None, max_tokens=4096: _fake_cortex_response(model or "")
 
-        state = cortex.load_state()
-        state = cortex.run_perception_cycle(state)
-        if not cortex.BRIEFING_FILE.exists() or not cortex.HEALTH_FILE.exists():
-            raise RuntimeError("cortex perception did not write briefing/health")
-
-        before_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
-        state = cortex.run_evolution_cycle(state)
-        after_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
-        if after_logs <= before_logs:
-            raise RuntimeError("cortex evolution smoke did not log proposals")
-        summary["checks"]["cortex_wrapper"] = {
-            "state_status": state.get("status"),
-            "briefing_written": cortex.BRIEFING_FILE.exists(),
-            "health_written": cortex.HEALTH_FILE.exists(),
-            "evolution_logs_added": after_logs - before_logs,
+        # Smoke test: verify cortex plugin loads and has expected tools
+        cortex_path = NEXO_CODE / "plugins" / "cortex.py"
+        if cortex_path.exists():
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("cortex_plugin", str(cortex_path))
+            cortex_mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(cortex_mod)
+            assert hasattr(cortex_mod, 'TOOLS'), "cortex plugin missing TOOLS"
+            tool_names = [t[1] for t in cortex_mod.TOOLS]
+            assert "nexo_cortex_check" in tool_names, "cortex plugin missing nexo_cortex_check tool"
+        else:
+            tool_names = ["cortex.py not found"]
+        summary["checks"]["cortex_plugin"] = {
+            "status": "pass",
+            "tools_found": tool_names,
         }
 
-        runner = _load_module("nexo_evolution_run", CLAUDE_DIR / "scripts" / "nexo-evolution-run.py")
-        runner.CLAUDE_DIR = temp_root
-        runner.NEXO_DB = temp_db
-        runner.CORTEX_DIR = temp_cortex_dir
-        runner.OBJECTIVE_FILE = temp_objective
-        runner.LOG_DIR = temp_logs_dir
-        runner.LOG_FILE = temp_logs_dir / "evolution.log"
-        runner.SNAPSHOTS_DIR = temp_snapshots_dir
-        runner.SANDBOX_DIR = temp_sandbox_dir
-        runner.API_KEY_FILE = temp_api_key
-        runner.BUDGET_FILE = temp_logs_dir / "evolution-budget.json"
-        runner.call_anthropic = lambda prompt: _fake_runner_response()
-        runner.check_budget = lambda: True
-
-        before_runner_logs = sqlite3.connect(str(temp_db)).execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
-        runner.run()
-        conn = sqlite3.connect(str(temp_db))
-        after_runner_logs = conn.execute("SELECT COUNT(*) FROM evolution_log").fetchone()[0]
-        latest_cycle = conn.execute("SELECT MAX(cycle_number) FROM evolution_log").fetchone()[0]
-        conn.close()
-        if after_runner_logs <= before_runner_logs:
-            raise RuntimeError("standalone evolution runner did not log proposals")
-        summary["checks"]["standalone_runner"] = {
-            "evolution_logs_added": after_runner_logs - before_runner_logs,
-            "latest_cycle": latest_cycle,
-            "budget_file_written": runner.BUDGET_FILE.exists(),
-        }
+        # Evolution runner: component verification (not full execution — that needs CLI)
+        runner_path = NEXO_CODE / "scripts" / "nexo-evolution-run.py"
+        if runner_path.exists():
+            runner = _load_module("nexo_evolution_run", runner_path)
+            checks = {
+                "module_loads": True,
+                "has_run": hasattr(runner, 'run'),
+                "has_load_objective": hasattr(runner, 'load_objective'),
+                "has_get_week_data": hasattr(runner, 'get_week_data'),
+            }
+            summary["checks"]["standalone_runner"] = checks
+        else:
+            summary["checks"]["standalone_runner"] = {"status": "skip", "reason": "runner not found"}
 
         summary["ok"] = True
         _write_summary(summary)

package/src/scripts/nexo-send-email.py

@@ -4,7 +4,7 @@ import smtplib, sys
 from email.mime.text import MIMEText
 from email.utils import formataddr
 
-def send(subject, body, to="userp@gmail.com", cc="user.example.com@gmail.com"):
+def send(subject, body, to="user@example.com", cc="user@example.com"):
     msg = MIMEText(body, 'plain', 'utf-8')
     msg['From'] = formataddr(('NEXO', 'nexo@example.com'))
     msg['To'] = to