nexo-brain 5.3.26 → 5.3.28

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

@@ -1,75 +0,0 @@
-#!/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

@@ -1,6 +0,0 @@
-#!/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

@@ -1,25 +0,0 @@
-#!/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

@@ -1,140 +0,0 @@
-#!/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

@@ -1,300 +0,0 @@
-#!/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()