nexo-brain 5.3.19 → 5.3.21

package/src/scripts/nexo-agent-run 2.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+"""Small CLI wrapper around the schedule-configured automation backend."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+_DEFAULT_RUNTIME_ROOT = _SCRIPT_DIR.parent
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_DEFAULT_RUNTIME_ROOT)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+
+
+def _read_text(path: str | None) -> str:
+    if not path:
+        return ""
+    return Path(path).expanduser().read_text()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Run a prompt through the configured NEXO automation backend.")
+    parser.add_argument("--prompt", default="", help="Prompt text")
+    parser.add_argument("--prompt-file", default="", help="Read prompt text from a file")
+    parser.add_argument("--cwd", default="", help="Working directory for the backend")
+    parser.add_argument("--task-profile", default="", help="Automation task profile: default|fast|balanced|deep")
+    parser.add_argument("--model", default="", help="Backend model hint")
+    parser.add_argument("--reasoning-effort", default="", help="Backend reasoning effort/profile")
+    parser.add_argument("--timeout", type=int, default=21600, help="Timeout in seconds")
+    parser.add_argument("--output-format", default="text", help="Requested output format")
+    parser.add_argument("--allowed-tools", default="", help="Claude-style allowed tools contract")
+    parser.add_argument("--append-system-prompt", default="", help="Extra system prompt text")
+    parser.add_argument("--append-system-prompt-file", default="", help="Read extra system prompt from a file")
+    args = parser.parse_args(argv)
+
+    prompt = args.prompt or _read_text(args.prompt_file)
+    if not prompt:
+        prompt = sys.stdin.read()
+    if not prompt.strip():
+        print("No prompt provided.", file=sys.stderr)
+        return 1
+
+    append_system_prompt = args.append_system_prompt or _read_text(args.append_system_prompt_file)
+
+    try:
+        result = run_automation_prompt(
+            prompt,
+            cwd=args.cwd or None,
+            task_profile=args.task_profile,
+            model=args.model,
+            reasoning_effort=args.reasoning_effort,
+            timeout=args.timeout,
+            output_format=args.output_format,
+            append_system_prompt=append_system_prompt,
+            allowed_tools=args.allowed_tools,
+        )
+    except AutomationBackendUnavailableError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+    if result.stdout:
+        print(result.stdout, end="" if result.stdout.endswith("\n") else "\n")
+    if result.stderr:
+        print(result.stderr, file=sys.stderr, end="" if result.stderr.endswith("\n") else "\n")
+    return int(result.returncode)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

package/src/scripts/nexo-catchup 2.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""NEXO Catch-Up — recover missed core cron windows after boot/wake.
+
+Recovery is driven by the explicit manifest contract plus cron_runs.
+Legacy .catchup-state.json is now only a fallback for pre-wrapper history.
+"""
+
+import fcntl
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+_DEFAULT_RUNTIME_ROOT = _SCRIPT_DIR.parent
+_runtime_root = Path(os.environ.get("NEXO_CODE", str(_DEFAULT_RUNTIME_ROOT)))
+if str(_runtime_root) not in sys.path:
+    sys.path.insert(0, str(_runtime_root))
+
+from agent_runner import AutomationBackendUnavailableError, probe_automation_backend, run_automation_prompt
+from cron_recovery import catchup_candidates
+
+HOME = Path.home()
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+
+
+def _resolve_claude_cli() -> Path:
+    """Find claude CLI: saved path > PATH > common locations."""
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        p = Path(saved.read_text().strip())
+        if p.exists():
+            return p
+    import shutil
+    found = shutil.which("claude")
+    if found:
+        return Path(found)
+    for candidate in [
+        HOME / ".local" / "bin" / "claude",
+        HOME / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ]:
+        if candidate.exists():
+            return candidate
+    return HOME / ".local" / "bin" / "claude"  # last resort
+
+
+CLAUDE_CLI = _resolve_claude_cli()
+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"
+LOCK_FILE = NEXO_HOME / "operations" / ".catchup.lock"
+
+SCRIPTS = NEXO_HOME / "scripts"
+WRAPPER = SCRIPTS / "nexo-cron-wrapper.sh"
+
+# 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")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def load_state() -> dict:
+    if STATE_FILE.exists():
+        try:
+            return json.loads(STATE_FILE.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def save_state(state: dict):
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def _resolve_runtime_command(script_type: str) -> str:
+    if script_type == "shell":
+        return "/bin/bash"
+    if script_type == "node":
+        return "node"
+    if script_type == "php":
+        return "php"
+    return NEXO_PYTHON
+
+
+def _acquire_lock():
+    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
+    handle = LOCK_FILE.open("w")
+    try:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        handle.close()
+        return None
+    handle.write(str(os.getpid()))
+    handle.flush()
+    return handle
+
+
+def _heal_personal_schedules() -> dict:
+    """Recreate declared personal schedules before catch-up checks missed windows."""
+    summary = {"created": 0, "repaired": 0, "invalid": 0, "error": ""}
+    try:
+        from script_registry import reconcile_personal_scripts
+        result = reconcile_personal_scripts(dry_run=False)
+        ensured = result.get("ensure_schedules", {})
+        summary["created"] = len(ensured.get("created", []))
+        summary["repaired"] = len(ensured.get("repaired", []))
+        summary["invalid"] = len(ensured.get("invalid", []))
+        if summary["created"] or summary["repaired"]:
+            log(
+                "Repaired declared personal schedules before catch-up: "
+                f"{summary['created']} created, {summary['repaired']} repaired."
+            )
+        if summary["invalid"]:
+            log(f"WARNING: {summary['invalid']} declared personal schedules are invalid.")
+    except Exception as e:
+        summary["error"] = str(e)
+        log(f"Personal schedule self-heal skipped: {e}")
+    return summary
+
+
+def run_task(candidate: dict, state: dict) -> bool:
+    """Execute a task and update state."""
+    name = candidate["cron_id"]
+    raw_script = str(candidate.get("script", ""))
+    script_candidate = Path(raw_script)
+    if script_candidate.is_absolute():
+        script_path = script_candidate
+    else:
+        script_path = SCRIPTS / script_candidate.name
+    script_name = script_path.name
+    if not script_path.exists():
+        log(f"  SKIP {name}: script not found ({script_path})")
+        return False
+
+    runtime_cmd = _resolve_runtime_command(candidate.get("type", "python"))
+    if WRAPPER.exists():
+        command = ["/bin/bash", str(WRAPPER), name, runtime_cmd, str(script_path)]
+    else:
+        command = [runtime_cmd, str(script_path)]
+
+    log(f"  RUNNING {name}: {script_name}")
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True, text=True, timeout=21600,
+            env={**os.environ, "HOME": str(HOME), "NEXO_CATCHUP": "1"}
+        )
+        if result.returncode == 0:
+            log(f"  OK {name} (exit 0)")
+            state[name] = datetime.now().isoformat()
+            save_state(state)
+            return True
+        else:
+            log(f"  FAIL {name} (exit {result.returncode})")
+            if result.stderr:
+                log(f"    stderr: {result.stderr[:300]}")
+            return False
+    except subprocess.TimeoutExpired:
+        log(f"  TIMEOUT {name} (21600s)")
+        return False
+    except Exception as e:
+        log(f"  ERROR {name}: {e}")
+        return False
+
+
+def main():
+    log("=== NEXO Catch-Up starting (boot/wake) ===")
+    lock_handle = _acquire_lock()
+    if lock_handle is None:
+        log("Catch-Up already running; skipping overlapping invocation.")
+        return
+
+    ran = 0
+    skipped = 0
+    skipped_out_of_window = 0
+    try:
+        _heal_personal_schedules()
+        state = load_state()
+        tasks = catchup_candidates()
+
+        for candidate in tasks:
+            name = candidate["cron_id"]
+            if not candidate.get("missed"):
+                skipped += 1
+                continue
+            if not candidate.get("within_window"):
+                skipped_out_of_window += 1
+                log(
+                    f"  SKIP {name}: missed window is {candidate['age_seconds']}s old "
+                    f"(max_catchup_age={candidate['contract']['max_catchup_age']}s)"
+                )
+                continue
+            due_at = candidate["last_due_at"].astimezone().strftime("%Y-%m-%d %H:%M")
+            log(f"  {name} — missed scheduled run due at {due_at}, catching up...")
+            if run_task(candidate, state):
+                ran += 1
+
+        if ran == 0 and skipped_out_of_window == 0:
+            log("All tasks up to date, nothing to catch up.")
+        elif ran >= 3:
+            # Many tasks caught up — ask CLI to assess system state
+            _cli_post_catchup_assessment(ran, skipped, state)
+        else:
+            suffix = f", {skipped_out_of_window} outside recovery window" if skipped_out_of_window else ""
+            log(f"Caught up {ran} tasks, {skipped} already current{suffix}.")
+
+        log("=== Catch-Up complete ===")
+    finally:
+        lock_handle.close()
+
+
+def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):
+    """When 3+ tasks were missed, use CLI to assess if there are concerns."""
+    probe = probe_automation_backend(timeout=30)
+    if not probe.get("ok"):
+        print(
+            f"[{datetime.now().strftime('%H:%M:%S')}] "
+            f"Automation backend unavailable. Skipping CLI analysis. ({probe.get('reason') or probe.get('stderr') or 'not ready'})"
+        )
+        return
+
+    assessment_file = LOG_DIR / "catchup-assessment.md"
+    state_summary = json.dumps(state, indent=2, default=str)
+
+    prompt = f"""You are the NEXO Catch-Up system. The Mac was off/asleep and {ran} scheduled tasks just ran as catch-up ({skipped} were already current).
+
+Task run state (timestamps of last successful runs):
+{state_summary}
+
+Assess:
+1. How long was the system likely offline? (compare timestamps to now)
+2. Are there any tasks that depend on each other where order matters?
+3. Any tasks that may have produced stale results because they ran late?
+4. Should any task be re-run at its normal time today?
+
+Write a brief assessment (max 20 lines) to: {assessment_file}
+
+Format:
+## Catch-Up Assessment — {datetime.now().strftime('%Y-%m-%d %H:%M')}
+- Offline duration: ~Xh
+- Tasks caught up: {ran}
+- Concerns: ...
+- Recommendation: ..."""
+
+    log(f"Caught up {ran} tasks — running CLI assessment...")
+    try:
+        result = run_automation_prompt(
+            prompt,
+            model=_USER_MODEL or "opus",
+            timeout=21600,
+            output_format="text",
+            allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
+        )
+        if result.returncode == 0:
+            log(f"Assessment written to {assessment_file}")
+        else:
+            log(f"CLI assessment exited {result.returncode}")
+    except AutomationBackendUnavailableError as e:
+        log(f"CLI assessment skipped: {e}")
+    except subprocess.TimeoutExpired:
+        log("CLI assessment timed out (90s)")
+    except Exception as e:
+        log(f"CLI assessment error: {e}")
+
+
+if __name__ == "__main__":
+    main()