nexo-brain 2.6.11 → 2.6.12

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 from __future__ import annotations
 """
-Deep Sleep v2 -- Phase 2: Extract findings from each session using Claude CLI.
+Deep Sleep v2 -- Phase 2: Extract findings from each session using the configured automation backend.
 
 For each session in the context file, sends the extract-prompt.md to Claude
 and collects structured findings. Merges all per-session results into
@@ -12,35 +12,23 @@ Environment variables:
 """
 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")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
 PROMPT_FILE = Path(__file__).parent / "extract-prompt.md"
 
-# No timeout -- user pays unlimited Claude Code, sessions can take as long as needed
-CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
 
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
-def find_claude_cli() -> str:
-    """Find the Claude CLI binary."""
-    # Check common locations
-    candidates = [
-        Path.home() / ".local" / "bin" / "claude",
-        Path("/usr/local/bin/claude"),
-    ]
-    for c in candidates:
-        if c.exists():
-            return str(c)
-    # Try PATH
-    which = shutil.which("claude")
-    if which:
-        return which
-    return "claude"  # Fallback, let it fail with a clear error
+# No timeout -- headless automation can take as long as needed
+CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
 
 
 def extract_json_from_response(text: str) -> dict | None:
@@ -88,10 +76,10 @@ def find_session_file(session_id: str, date_dir: Path) -> Path | None:
     return None
 
 
-def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path | None, claude_bin: str) -> dict | None:
-    """Send a session to Claude CLI for extraction analysis.
+def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path | None) -> dict | None:
+    """Send a session to the automation backend for extraction analysis.
 
-    Claude CLI reads the small per-session file + shared context file.
+    The backend reads the small per-session file + shared context file.
     Prompt is short — the heavy lifting is in the Read tool calls.
     """
     session_file = find_session_file(session_id, date_dir)
@@ -112,35 +100,23 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
     prompt += shared_ctx_instruction
 
     try:
-        env = os.environ.copy()
-        env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-        env.pop("CLAUDECODE", None)
-        env.pop("CLAUDE_CODE", None)
-
         JSON_SYSTEM_PROMPT = (
             "You are a JSON-only analyst. Your ENTIRE response must be a single valid JSON object. "
             "No text before it. No text after it. No markdown fences. No explanations. "
             "If you want to summarize, put it inside the JSON fields. Start with { and end with }."
         )
 
-        result = subprocess.run(
-            [
-                claude_bin,
-                "-p", prompt,
-                "--model", "opus",
-                "--output-format", "text",
-                "--append-system-prompt", JSON_SYSTEM_PROMPT,
-                "--allowedTools",
-                "Read,Grep,Bash"
-            ],
-            capture_output=True,
-            text=True,
+        result = run_automation_prompt(
+            prompt,
+            model="opus",
             timeout=CLAUDE_TIMEOUT,
-            env=env
+            output_format="text",
+            append_system_prompt=JSON_SYSTEM_PROMPT,
+            allowed_tools="Read,Grep,Bash",
         )
 
         if result.returncode != 0:
-            print(f"    Claude CLI error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
+            print(f"    Automation backend error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
             return None
 
         # Filter out stop hook contamination (e.g. "Post-mortem completo.")
@@ -160,11 +136,12 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
                 f"Required schema: session_id, findings[], emotional_timeline[], "
                 f"abandoned_projects[], skill_candidates[], productivity_score, protocol_summary"
             )
-            convert_result = subprocess.run(
-                [claude_bin, "-p", convert_prompt, "--model", "sonnet",
-                 "--output-format", "text",
-                 "--append-system-prompt", JSON_SYSTEM_PROMPT],
-                capture_output=True, text=True, timeout=120, env=env
+            convert_result = run_automation_prompt(
+                convert_prompt,
+                model="sonnet",
+                timeout=120,
+                output_format="text",
+                append_system_prompt=JSON_SYSTEM_PROMPT,
             )
             if convert_result.returncode == 0:
                 parsed = extract_json_from_response(convert_result.stdout)
@@ -180,13 +157,12 @@ def analyze_session(session_id: str, date_dir: Path, shared_context_file: Path |
 
         return parsed
 
+    except AutomationBackendUnavailableError as exc:
+        print(f"    Automation backend unavailable: {exc}", file=sys.stderr)
+        return None
     except subprocess.TimeoutExpired:
-        print(f"    Claude CLI timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
+        print(f"    Automation backend timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
         return None
-    except FileNotFoundError:
-        print(f"    Claude CLI not found at: {claude_bin}", file=sys.stderr)
-        print("    Install: npm install -g @anthropic-ai/claude-code", file=sys.stderr)
-        sys.exit(1)
 
 
 def main():
@@ -235,9 +211,8 @@ def main():
         shared_context_file = None
         print("[extract] No shared context file")
 
-    claude_bin = find_claude_cli()
     print(f"[extract] Phase 2: Analyzing {len(session_files)} sessions for {target_date}")
-    print(f"[extract] Claude CLI: {claude_bin}")
+    print("[extract] Automation backend: schedule-configured")
 
     # Checkpoint directory: one JSON per session, survives crashes
     checkpoint_dir = date_dir / "checkpoints"
@@ -271,7 +246,7 @@ def main():
         # Retry loop
         result = None
         for attempt in range(1, MAX_RETRIES + 1):
-            result = analyze_session(session_id, date_dir, shared_context_file, claude_bin)
+            result = analyze_session(session_id, date_dir, shared_context_file)
             if result:
                 break
             if attempt < MAX_RETRIES:

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

@@ -12,7 +12,6 @@ Environment variables:
 """
 import json
 import os
-import shutil
 import subprocess
 import sys
 from datetime import datetime
@@ -26,22 +25,9 @@ PROMPT_FILE = Path(__file__).parent / "synthesize-prompt.md"
 if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
-CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
-
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
-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"
+CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
 
 
 def extract_json_from_response(text: str) -> dict | None:
@@ -144,34 +130,21 @@ def main():
     prompt = prompt.replace("{{CONTEXT_FILE}}", str(context_file))
     prompt = prompt.replace("{{SKILL_RUNTIME_FILE}}", str(runtime_candidates_file))
 
-    claude_bin = find_claude_cli()
     print(f"[synthesize] Phase 3: Synthesizing {total_findings} findings from {target_date}")
     print(f"[synthesize] Skill runtime candidates: {runtime_candidate_count}")
-    print(f"[synthesize] Claude CLI: {claude_bin}")
+    print("[synthesize] Automation backend: schedule-configured")
 
     try:
-        env = os.environ.copy()
-        env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-        env.pop("CLAUDECODE", None)
-        env.pop("CLAUDE_CODE", None)
-
-        result = subprocess.run(
-            [
-                claude_bin,
-                "-p", prompt,
-                "--model", "opus",
-                "--output-format", "text",
-                "--allowedTools",
-                "Read,Grep,Bash"
-            ],
-            capture_output=True,
-            text=True,
+        result = run_automation_prompt(
+            prompt,
+            model="opus",
             timeout=CLAUDE_TIMEOUT,
-            env=env
+            output_format="text",
+            allowed_tools="Read,Grep,Bash",
         )
 
         if result.returncode != 0:
-            print(f"[synthesize] Claude CLI error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
+            print(f"[synthesize] Automation backend error (exit {result.returncode}): {result.stderr[:300]}", file=sys.stderr)
             sys.exit(1)
 
         # Filter hook contamination
@@ -218,11 +191,14 @@ def main():
         print(f"  Context packets: {n_packets}")
         print(f"[synthesize] Output: {output_file}")
 
+    except AutomationBackendUnavailableError as exc:
+        print(f"[synthesize] Automation backend unavailable: {exc}", file=sys.stderr)
+        sys.exit(1)
     except subprocess.TimeoutExpired:
-        print(f"[synthesize] Claude CLI timeout ({CLAUDE_TIMEOUT}s)", file=sys.stderr)
+        print(f"[synthesize] Automation backend 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)
+        print("[synthesize] Automation backend binary not found.", file=sys.stderr)
         sys.exit(1)
 
 

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

@@ -0,0 +1,73 @@
+#!/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("--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,
+            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-catchup.py

@@ -19,6 +19,7 @@ _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()
@@ -237,16 +238,12 @@ def main():
 
 def _cli_post_catchup_assessment(ran: int, skipped: int, state: dict):
     """When 3+ tasks were missed, use CLI to assess if there are concerns."""
-    if not CLAUDE_CLI.exists():
-        log(f"Caught up {ran} tasks, {skipped} already current. (CLI unavailable for assessment)")
-        return
-    auth_check = subprocess.run(
-        [str(CLAUDE_CLI), "-p", "reply OK", "--output-format", "text"],
-        capture_output=True, text=True, timeout=30
-    )
-    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.")
+    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"
@@ -273,21 +270,20 @@ Format:
 - Recommendation: ..."""
 
     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", "--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:
             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:

package/src/scripts/nexo-daily-self-audit.py

@@ -6,7 +6,7 @@ Stage A — Mechanical checks (Python pure, unchanged):
   18 checks: overdue reminders, disk space, DB size, stale sessions, guard stats,
   cognitive health, snapshot drift, etc. All pure queries, no intelligence needed.
 
-Stage B — Interpretation (Claude CLI opus):
+Stage B — Interpretation (automation backend):
   Takes the raw findings from Stage A and UNDERSTANDS them:
   - Groups related findings
   - Identifies root causes
@@ -30,6 +30,10 @@ NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 _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)))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
@@ -432,7 +436,7 @@ def check_cognitive_health():
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Stage B: Interpretation (Claude CLI opus) — NEW in v2
+# Stage B: Interpretation (automation backend) — NEW in v2
 # ═══════════════════════════════════════════════════════════════════════════════
 
 def interpret_findings(raw_findings: list) -> bool:
@@ -479,20 +483,16 @@ via sqlite3 nexo.db 'UPDATE...'" is useful.
 
 Also write the machine-readable summary to {LOG_DIR}/self-audit-summary.json.
 
-Execute without asking."""
-
-    log("Stage B: Invoking Claude CLI (opus) for interpretation...")
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
+    Execute without asking."""
 
+    log("Stage B: Invoking automation backend for interpretation...")
     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:
@@ -502,6 +502,9 @@ Execute without asking."""
         log(f"Stage B: Interpretation complete ({len(result.stdout or '')} chars)")
         return True
 
+    except AutomationBackendUnavailableError as e:
+        log(f"Stage B: automation backend unavailable: {e}")
+        return False
     except subprocess.TimeoutExpired:
         log("Stage B: CLI timed out")
         return False

package/src/scripts/nexo-evolution-run.py

@@ -122,7 +122,7 @@ def _immutable_files_for_mode(mode: str) -> set[str]:
         return set(GLOBAL_IMMUTABLE_FILES)
     return set(GLOBAL_IMMUTABLE_FILES) | set(STANDARD_MODE_IMMUTABLE_FILES)
 
-# ── Claude CLI path ──────────────────────────────────────────────────────
+# ── Automation backend pathing ───────────────────────────────────────────
 def _resolve_claude_cli() -> Path:
     """Find claude CLI: saved path > PATH > common locations."""
     import shutil as _shutil
@@ -169,6 +169,7 @@ def log(msg: str):
 
 # ── Import from evolution_cycle.py (lives in NEXO_CODE, i.e. src/) ──────
 sys.path.insert(0, str(NEXO_CODE))
+from agent_runner import probe_automation_backend, run_automation_prompt
 from evolution_cycle import (
     load_objective, save_objective, get_week_data, build_evolution_prompt,
     dry_run_restore_test, max_auto_changes, create_snapshot, build_public_contribution_prompt
@@ -197,39 +198,23 @@ def set_consecutive_failures(count: int):
     save_objective(obj)
 
 
-# ── Claude CLI call ──────────────────────────────────────────────────────
+# ── Automation backend call ──────────────────────────────────────────────
 CLI_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
 
 
 def verify_claude_cli() -> bool:
-    """Check Claude CLI is available and authenticated."""
-    if not CLAUDE_CLI.exists():
-        return False
-    try:
-        result = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "reply OK", "--output-format", "text"],
-            capture_output=True, text=True, timeout=30
-        )
-        return result.returncode == 0
-    except Exception:
-        return False
+    """Check the configured automation backend is available and authenticated."""
+    return bool(probe_automation_backend(timeout=30).get("ok"))
 
 
 def call_claude_cli(prompt: str) -> str:
-    """Call claude -p prompt --model opus via subprocess. Returns stdout text."""
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
-
-    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,
+    """Call the configured automation backend for the managed evolution prompt."""
+    result = run_automation_prompt(
+        prompt,
+        model="opus",
         timeout=CLI_TIMEOUT,
-        env=env,
+        output_format="text",
+        allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
     )
     if result.returncode != 0:
         raise RuntimeError(f"claude CLI exited {result.returncode}: {result.stderr[:500]}")
@@ -237,30 +222,15 @@ def call_claude_cli(prompt: str) -> str:
 
 
 def call_public_claude_cli(prompt: str, *, cwd: Path) -> str:
-    """Run Claude CLI in an isolated public repo checkout."""
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"
-    env["NEXO_PUBLIC_CONTRIBUTION"] = "1"
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
-
-    result = subprocess.run(
-        [
-            str(CLAUDE_CLI),
-            "-p",
-            prompt,
-            "--model",
-            "opus",
-            "--output-format",
-            "text",
-            "--allowedTools",
-            "Read,Write,Edit,Glob,Grep,Bash",
-        ],
-        cwd=str(cwd),
-        capture_output=True,
-        text=True,
+    """Run the configured automation backend in an isolated public repo checkout."""
+    result = run_automation_prompt(
+        prompt,
+        cwd=cwd,
+        env={"NEXO_PUBLIC_CONTRIBUTION": "1"},
+        model="opus",
         timeout=CLI_TIMEOUT,
-        env=env,
+        output_format="text",
+        allowed_tools="Read,Write,Edit,Glob,Grep,Bash",
     )
     if result.returncode != 0:
         raise RuntimeError(f"claude CLI exited {result.returncode}: {result.stderr[:500]}")
@@ -514,7 +484,7 @@ def run_public_contribution_cycle(*, objective: dict, cycle_num: int) -> None:
         return
 
     if not verify_claude_cli():
-        log("Claude CLI not available or not authenticated. Skipping public contribution run.")
+        log("Automation backend not available or not authenticated. Skipping public contribution run.")
         mark_public_contribution_result(result="skipped:claude_cli_unavailable", config=config)
         return
 
@@ -930,17 +900,17 @@ def run():
     prompt = build_evolution_prompt(week_data, objective)
     log(f"Prompt built: {len(prompt)} chars")
 
-    # Verify Claude CLI is authenticated before calling
+    # Verify the configured automation backend is available before calling
     if not verify_claude_cli():
-        log("Claude CLI not available or not authenticated. Skipping evolution run.")
+        log("Automation backend not available or not authenticated. Skipping evolution run.")
         return
 
-    # Call Opus via claude -p
-    log("Calling claude -p --model opus...")
+    # Call the configured automation backend with the legacy opus task profile
+    log("Calling automation backend with the opus task profile...")
     try:
         raw_response = call_claude_cli(prompt)
     except Exception as e:
-        log(f"claude CLI call failed: {e}")
+        log(f"Automation backend call failed: {e}")
         set_consecutive_failures(failures + 1)
         return
 

package/src/scripts/nexo-immune.py

@@ -24,6 +24,14 @@ 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
+
 from urllib.request import Request, urlopen
 from urllib.error import URLError, HTTPError
 
@@ -855,11 +863,7 @@ def _run_checks(lock_fd):
 
 
 def _run_cli_triage(all_results: dict, repairs: list, counts: dict):
-    """Pass all findings to Claude CLI for intelligent triage and recommendations."""
-    if not CLAUDE_CLI.exists():
-        print("[SKIP] Claude CLI not found, skipping triage")
-        return
-
+    """Pass all findings to the configured automation backend for intelligent triage and recommendations."""
     triage_file = COORD_DIR / "immune-triage.md"
     findings_json = json.dumps({
         "timestamp": NOW.strftime("%Y-%m-%d %H:%M"),
@@ -901,22 +905,20 @@ Raw findings:
 Write the report. Be concise — max 40 lines."""
 
     print("\n[TRIAGE] Running CLI interpretation...")
-    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",
-             "--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:
             print(f"[TRIAGE] Report written to {triage_file}")
         else:
             print(f"[TRIAGE] CLI exited {result.returncode}: {result.stderr[:200]}")
+    except AutomationBackendUnavailableError as e:
+        print(f"[TRIAGE] Skipping triage: {e}")
     except subprocess.TimeoutExpired:
         print("[TRIAGE] CLI timed out (120s)")
     except Exception as e: