nexo-brain 2.6.11 → 2.6.13

package/src/scripts/nexo-sleep.py

@@ -4,7 +4,7 @@ NEXO Sleep System v2 — The brain dreams.
 
 Before: 834 lines with word-overlap "intelligence" for learning consolidation.
 Now: Stage A (mechanical cleanup) stays pure Python. Stage B (dreaming) uses
-Claude CLI (opus) to understand, deduplicate, and prune with real intelligence.
+the configured automation backend to understand, deduplicate, and prune with real intelligence.
 
 Triggered hourly via LaunchAgent. Runs ONCE per day, first time Mac is awake.
 If interrupted (power loss, crash), resumes on next trigger.
@@ -12,7 +12,7 @@ If interrupted (power loss, crash), resumes on next trigger.
 Stage A — Housekeeping (Python pure):
   Delete old logs, rotate files, trim JSON. No intelligence needed.
 
-Stage B — Dreaming (Claude CLI opus):
+Stage B — Dreaming (automation backend):
   Review learnings for duplicates and contradictions with UNDERSTANDING.
   Prune MEMORY.md if over limit. Clean preferences. Compress old observations.
   One CLI call that does what 500 lines of word-overlap couldn't.
@@ -30,6 +30,13 @@ from datetime import datetime, date, timedelta
 from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
 # ─── Paths ────────────────────────────────────────────────────────────────────
 CLAUDE_DIR = NEXO_HOME
@@ -293,7 +300,7 @@ def stage_a_cleanup() -> dict:
     return stats
 
 
-# ─── Stage B: Dreaming (Claude CLI) ─────────────────────────────────────────
+# ─── Stage B: Dreaming (automation backend) ─────────────────────────────────
 
 def collect_brain_state() -> dict:
     """Collect all data the CLI needs to dream."""
@@ -428,18 +435,14 @@ ABSOLUTE RULES:
 Write a summary to {COORD_DIR}/sleep-report.md when done.
 Execute without asking."""
 
-    log("Stage B: Invoking Claude CLI (opus) — dreaming...")
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
-
+    log("Stage B: Invoking automation backend — dreaming...")
     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
+        result = run_automation_prompt(
+            prompt,
+            model="opus",
+            timeout=21600,
+            output_format="text",
+            allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
         )
 
         if result.returncode != 0:
@@ -449,6 +452,9 @@ Execute without asking."""
         log(f"Stage B: Dreaming complete. Output: {len(result.stdout or '')} chars")
         return {"ok": True, "output_len": len(result.stdout or "")}
 
+    except AutomationBackendUnavailableError as e:
+        log(f"Stage B: automation backend unavailable: {e}")
+        return {"error": "backend-unavailable"}
     except subprocess.TimeoutExpired:
         log("Stage B: CLI timed out (600s)")
         return {"error": "timeout"}

package/src/scripts/nexo-synthesis.py

@@ -3,7 +3,7 @@
 NEXO Synthesis Engine v2 — Daily intelligence brief.
 
 Before: ~400 lines of Python concatenating SQL results into markdown sections.
-Now: Collects raw data, passes to Claude CLI (sonnet) which synthesizes
+Now: Collects raw data, passes to the configured automation backend which synthesizes
 with real understanding of what matters for tomorrow.
 
 Runs daily at 06:00 via LaunchAgent.
@@ -20,6 +20,14 @@ from pathlib import Path
 
 HOME = Path.home()
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+
 CLAUDE_DIR = NEXO_HOME
 COORD_DIR = CLAUDE_DIR / "coordination"
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
@@ -204,18 +212,14 @@ not what merely happened. If a section has nothing, write "Nothing notable."
 
 Execute without asking."""
 
-    log("Invoking Claude CLI (opus) for synthesis...")
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
-
+    log("Invoking automation backend for synthesis...")
     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
+        result = run_automation_prompt(
+            prompt,
+            model="opus",
+            timeout=21600,
+            output_format="text",
+            allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
         )
 
         if result.returncode != 0:
@@ -225,6 +229,9 @@ Execute without asking."""
         log(f"Synthesis complete. Output: {len(result.stdout or '')} chars")
         return True
 
+    except AutomationBackendUnavailableError as e:
+        log(f"Automation backend unavailable: {e}")
+        return False
     except subprocess.TimeoutExpired:
         log("CLI timed out (180s)")
         return False

package/src/scripts/nexo-update.sh

@@ -250,8 +250,34 @@ fi
 # --- Step 9: Sync shared client configs ---
 CLIENT_SYNC="$SRC_DIR/scripts/nexo-sync-clients.py"
 if [ -f "$CLIENT_SYNC" ]; then
-    log "Syncing Claude Code, Claude Desktop, and Codex configs..."
-    if NEXO_HOME="$NEXO_HOME" NEXO_CODE="$SRC_DIR" python3 "$CLIENT_SYNC" --nexo-home "$NEXO_HOME" --runtime-root "$SRC_DIR" --json >/dev/null 2>&1; then
+    log "Syncing shared client configs..."
+    CLIENT_SYNC_ARGS=()
+    if [ -f "$NEXO_HOME/config/schedule.json" ]; then
+        while IFS= read -r line; do
+            [ -n "$line" ] && CLIENT_SYNC_ARGS+=("--enabled-client" "$line")
+        done < <(
+            NEXO_HOME="$NEXO_HOME" NEXO_CODE="$SRC_DIR" python3 - <<'PY'
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, os.environ["NEXO_CODE"])
+from client_preferences import normalize_client_preferences
+
+schedule_file = Path(os.environ["NEXO_HOME"]) / "config" / "schedule.json"
+prefs = normalize_client_preferences(json.loads(schedule_file.read_text())) if schedule_file.exists() else normalize_client_preferences({})
+enabled = [key for key, value in prefs.get("interactive_clients", {}).items() if value]
+if prefs.get("automation_enabled", True):
+    backend = prefs.get("automation_backend")
+    if backend and backend != "none" and backend not in enabled:
+        enabled.append(backend)
+for item in enabled:
+    print(item)
+PY
+        )
+    fi
+    if NEXO_HOME="$NEXO_HOME" NEXO_CODE="$SRC_DIR" python3 "$CLIENT_SYNC" --nexo-home "$NEXO_HOME" --runtime-root "$SRC_DIR" "${CLIENT_SYNC_ARGS[@]}" --json >/dev/null 2>&1; then
         log "Shared client configs synced."
     else
         warn "Client config sync failed (non-fatal). Run 'nexo clients sync' later."

package/src/scripts/nexo-watchdog.sh

@@ -64,7 +64,9 @@ import json, sys, platform
 nexo_home = '$NEXO_HOME'
 is_mac = platform.system() == 'Darwin'
 optionals_file = '$NEXO_HOME/config/optionals.json'
+schedule_file = '$NEXO_HOME/config/schedule.json'
 optionals = {}
+automation_default = True
 
 with open('$MANIFEST_FILE') as f:
     data = json.load(f)
@@ -77,10 +79,22 @@ try:
 except Exception:
     optionals = {}
 
+try:
+    with open(schedule_file) as f:
+        schedule = json.load(f)
+        if isinstance(schedule, dict):
+            automation_default = bool(schedule.get('automation_enabled', True))
+except Exception:
+    automation_default = True
+
 for c in data.get('crons', []):
     cid = c['id']
     optional_key = c.get('optional')
-    if optional_key and not optionals.get(optional_key, False):
+    if optional_key == 'automation':
+        optional_enabled = optionals.get(optional_key, automation_default)
+    else:
+        optional_enabled = optionals.get(optional_key, False)
+    if optional_key and not optional_enabled:
         continue
     name = cid.replace('-', ' ').title()
     # Use the right service identifier per platform
@@ -1126,18 +1140,28 @@ CONSTRAINTS:
 - Log what you did to $NEXO_HOME/logs/watchdog-repair-result.log
 NEXOPROMPT
 
-      # Launch NEXO in background with repair task
-      # Ensure claude CLI is in PATH (cron/LaunchAgent may have minimal PATH)
-      CLAUDE_BIN=$(command -v claude 2>/dev/null || echo "$HOME_DIR/.claude/local/bin/claude")
-      if [ ! -x "$CLAUDE_BIN" ]; then
-        CLAUDE_BIN=$(find /usr/local/bin /opt/homebrew/bin "$HOME_DIR/.local/bin" "$HOME_DIR/.npm-global/bin" -name claude -type f 2>/dev/null | head -1)
+      # Launch NEXO in background with the configured automation backend.
+      # Keep the hardened Claude fallback for older runtimes or partial installs.
+      AGENT_RUNNER="$NEXO_HOME/scripts/nexo-agent-run.py"
+      NEXO_PYTHON="$NEXO_HOME/.venv/bin/python3"
+      if [ ! -x "$NEXO_PYTHON" ]; then
+        NEXO_PYTHON=$(command -v python3 2>/dev/null || echo "python3")
       fi
 
-      if [ -n "$CLAUDE_BIN" ] && [ -x "$CLAUDE_BIN" ]; then
-        nohup bash -c "\"$CLAUDE_BIN\" --print --dangerously-skip-permissions -p \"\$(cat '$REPAIR_PROMPT_FILE')\" >> '$LOG_DIR/watchdog-nexo-repair.log' 2>&1; rm -f '$REPAIR_PROMPT_FILE'" &
+      if [ -f "$AGENT_RUNNER" ]; then
+        nohup bash -c "\"$NEXO_PYTHON\" \"$AGENT_RUNNER\" --prompt-file '$REPAIR_PROMPT_FILE' >> '$LOG_DIR/watchdog-nexo-repair.log' 2>&1; rm -f '$REPAIR_PROMPT_FILE'" &
       else
-        log "NEXO repair ABORTED: claude CLI not found in PATH"
-        rm -f "$REPAIR_PROMPT_FILE"
+        CLAUDE_BIN=$(command -v claude 2>/dev/null || echo "$HOME_DIR/.claude/local/bin/claude")
+        if [ ! -x "$CLAUDE_BIN" ]; then
+          CLAUDE_BIN=$(find /usr/local/bin /opt/homebrew/bin "$HOME_DIR/.local/bin" "$HOME_DIR/.npm-global/bin" -name claude -type f 2>/dev/null | head -1)
+        fi
+
+        if [ -n "$CLAUDE_BIN" ] && [ -x "$CLAUDE_BIN" ]; then
+          nohup bash -c "\"$CLAUDE_BIN\" --print --dangerously-skip-permissions -p \"\$(cat '$REPAIR_PROMPT_FILE')\" >> '$LOG_DIR/watchdog-nexo-repair.log' 2>&1; rm -f '$REPAIR_PROMPT_FILE'" &
+        else
+          log "NEXO repair ABORTED: no automation backend wrapper and no claude CLI fallback found"
+          rm -f "$REPAIR_PROMPT_FILE"
+        fi
       fi
 
       REPAIR_PID=$!

package/templates/nexo_helper.py

@@ -9,7 +9,13 @@ All communication goes through the stable `nexo scripts call` CLI.
 from __future__ import annotations
 
 import json
+import os
 import subprocess
+import sys
+from pathlib import Path
+
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
 
 def run_nexo(args: list[str]) -> str:
@@ -43,3 +49,42 @@ def call_tool_json(name: str, payload: dict | None = None) -> dict:
     args = ["scripts", "call", name, "--input", json.dumps(payload or {}), "--json-output"]
     out = run_nexo(args)
     return json.loads(out)
+
+
+def run_automation_text(
+    prompt: str,
+    *,
+    model: str = "",
+    reasoning_effort: str = "",
+    cwd: str = "",
+) -> str:
+    """Run the configured NEXO automation backend and return text output.
+
+    This avoids hardcoding provider CLIs such as `claude -p` inside personal
+    scripts. The runtime routes the call through the selected backend and its
+    configured model profile.
+    """
+    runner = NEXO_HOME / "scripts" / "nexo-agent-run.py"
+    if not runner.exists():
+        raise RuntimeError(f"Automation runner not found: {runner}")
+
+    cmd = [sys.executable, str(runner), "--prompt", prompt, "--output-format", "text"]
+    if model:
+        cmd.extend(["--model", model])
+    if reasoning_effort:
+        cmd.extend(["--reasoning-effort", reasoning_effort])
+    if cwd:
+        cmd.extend(["--cwd", cwd])
+
+    env = os.environ.copy()
+    env.setdefault("NEXO_HOME", str(NEXO_HOME))
+    env.setdefault("NEXO_CODE", env.get("NEXO_CODE", str(NEXO_HOME)))
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or result.stdout.strip() or f"automation backend exited {result.returncode}")
+    return result.stdout

package/templates/plugin-template.py

@@ -2,6 +2,10 @@
 
 This file lives in NEXO_HOME/plugins/ and is loaded by the NEXO MCP server.
 Edit the handler below to implement your personal capability.
+
+If this plugin ever needs an autonomous model call, route it through the
+configured NEXO automation backend instead of hardcoding `claude -p` or
+provider-specific model names directly inside the plugin.
 """
 
 from __future__ import annotations

package/templates/script-template.py

@@ -13,6 +13,7 @@
 This template demonstrates:
 - Inline metadata for auto-discovery
 - Safe CLI calls through nexo_helper
+- Optional agent calls through the configured automation backend
 - Timeout handling (via metadata)
 - argparse for user arguments
 - No direct DB access
@@ -25,11 +26,21 @@ import sys
 # nexo_helper.py is in NEXO_HOME/templates/ — copy it next to your script
 # or add the templates dir to your path
 try:
-    from nexo_helper import call_tool_text
+    from nexo_helper import call_tool_text, run_automation_text
 except ImportError:
     import os
     sys.path.insert(0, os.path.join(os.environ.get("NEXO_HOME", "~/.nexo"), "templates"))
-    from nexo_helper import call_tool_text
+    from nexo_helper import call_tool_text, run_automation_text
+
+# If this script ever needs an autonomous model call:
+#   1. use run_automation_text(...)
+#   2. pass a legacy task profile like model="opus" when useful
+#   3. DO NOT hardcode `claude -p` or provider-specific model defaults
+# Example:
+#   result = run_automation_text(
+#       "Summarize pending issues",
+#       model="opus",  # legacy task profile; NEXO maps it per backend
+#   )
 
 
 def main():

package/templates/skill-script-template.py

@@ -3,6 +3,8 @@
 
 This script is meant to be referenced by a Skill v2 definition.
 It should use the stable NEXO CLI rather than importing internal DB modules.
+If it needs an agentic model call, route it through NEXO's configured
+automation backend instead of hardcoding `claude -p` or a provider model.
 """
 
 import argparse
@@ -35,5 +37,11 @@ def main() -> int:
     return result.returncode
 
 
+# Agentic example for future edits:
+#   from nexo_helper import run_automation_text
+#   result = run_automation_text("Analyze this", model="opus")
+#   print(result)
+
+
 if __name__ == "__main__":
     raise SystemExit(main())