nexo-brain 2.6.11 → 2.6.13

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:

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

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 """
-NEXO Learning Validator — Cross-checks findings against existing learnings.
+NEXO Learning Validator — Cross-check findings against existing learnings.
 
-Wrapper collects the finding + all learnings from SQLite, then passes
-to Claude CLI (opus) to make an intelligent determination of whether
-the finding is known, related, or genuinely new.
+The wrapper collects the finding + current learnings from SQLite, then asks the
+configured automation backend whether the finding is already known, related, or
+genuinely new. If the backend is unavailable, it falls back to mechanical
+similarity matching.
 
 Usage as CLI:
     python3 nexo-learning-validator.py "finding text to validate"
@@ -21,27 +22,36 @@ Exit codes:
     1 = Finding is KNOWN (matches existing learning)
 """
 
+from __future__ import annotations
+
 import json
 import os
 import sqlite3
-import subprocess
 import sys
 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[1])))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+
 
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+JSON_ONLY_SYSTEM_PROMPT = (
+    "Return exactly one valid JSON object. No markdown fences. No prose outside JSON."
+)
 
 
-def get_all_learnings(category: str = None) -> list[dict]:
+def get_all_learnings(category: str | None = None) -> list[dict]:
     """Fetch all learnings from nexo.db."""
     conn = sqlite3.connect(str(NEXO_DB), timeout=10)
     conn.row_factory = sqlite3.Row
     if category:
         rows = conn.execute(
             "SELECT id, category, title, content FROM learnings WHERE category = ?",
-            (category,)
+            (category,),
         ).fetchall()
     else:
         rows = conn.execute(
@@ -51,9 +61,38 @@ def get_all_learnings(category: str = None) -> list[dict]:
     return [dict(r) for r in rows]
 
 
-def validate_finding(finding: str, category: str = None) -> dict:
+def _extract_json(text: str) -> dict | None:
+    text = (text or "").strip()
+    if not text:
+        return None
+    if text.startswith("```"):
+        lines = text.splitlines()
+        end = len(lines)
+        for idx in range(len(lines) - 1, 0, -1):
+            if lines[idx].strip() == "```":
+                end = idx
+                break
+        text = "\n".join(lines[1:end]).strip()
+    brace_start = text.find("{")
+    if brace_start < 0:
+        return None
+    depth = 0
+    for idx in range(brace_start, len(text)):
+        if text[idx] == "{":
+            depth += 1
+        elif text[idx] == "}":
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[brace_start:idx + 1])
+                except json.JSONDecodeError:
+                    return None
+    return None
+
+
+def validate_finding(finding: str, category: str | None = None) -> dict:
     """
-    Validate a finding against existing learnings using Claude CLI.
+    Validate a finding against existing learnings.
 
     Returns:
         {
@@ -70,18 +109,18 @@ def validate_finding(finding: str, category: str = None) -> dict:
             "known": False,
             "confidence": 0,
             "matching_learnings": [],
-            "recommendation": "No learnings in DB — finding is new by default"
+            "recommendation": "No learnings in DB — finding is new by default",
         }
 
-    # Build compact learnings reference for CLI
-    learnings_ref = []
-    for l in learnings:
-        learnings_ref.append({
+    learnings_ref = [
+        {
             "id": l["id"],
             "cat": l["category"],
             "title": l["title"],
             "content": (l["content"] or "")[:300],
-        })
+        }
+        for l in learnings
+    ]
 
     prompt = f"""You are a finding deduplication engine. Compare a new finding against existing learnings and determine if it's already known.
 
@@ -89,9 +128,9 @@ NEW FINDING:
 {finding}
 
 EXISTING LEARNINGS ({len(learnings_ref)} total):
-{json.dumps(learnings_ref, indent=1)}
+{json.dumps(learnings_ref, indent=1, ensure_ascii=False)}
 
-Respond with ONLY valid JSON (no markdown, no code fences):
+Respond with ONLY valid JSON:
 {{
   "known": true/false,
   "confidence": 0.0-1.0,
@@ -109,33 +148,27 @@ Rules:
 - If the finding describes the SAME bug/issue/pattern as a learning, it's known even if worded differently
 - Be strict: different symptoms of different bugs are NOT the same even if they mention the same file"""
 
-    # Try CLI first, fall back to mechanical similarity
-    if CLAUDE_CLI.exists():
-        try:
-            env = os.environ.copy()
-            env["NEXO_HEADLESS"] = "1"
-            env.pop("CLAUDECODE", None)
-            env.pop("CLAUDE_CODE", None)
-            learnings_text = "\n".join(
-                f"[#{l.get('id','')}] {l.get('title','')}: {l.get('content','')[:200]}"
-                for l in learnings[:20]
-            )
-            prompt = f"{VALIDATE_PROMPT}\n\nFinding:\n{finding}\n\nExisting learnings:\n{learnings_text}"
-            result = subprocess.run(
-                [str(CLAUDE_CLI), "-p", prompt, "--model", "sonnet", "--output-format", "text"],
-                capture_output=True, text=True, timeout=60, env=env
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                parsed = json.loads(result.stdout.strip())
-                return parsed
-        except Exception:
-            pass
-    # Fallback: mechanical SequenceMatcher (original logic)
+    try:
+        result = run_automation_prompt(
+            prompt,
+            model="sonnet",
+            timeout=60,
+            output_format="text",
+            append_system_prompt=JSON_ONLY_SYSTEM_PROMPT,
+        )
+        parsed = _extract_json(result.stdout)
+        if result.returncode == 0 and parsed:
+            return parsed
+    except AutomationBackendUnavailableError:
+        pass
+    except Exception:
+        pass
+
     return _mechanical_validate(finding, learnings)
 
 
 def _mechanical_validate(finding: str, learnings: list[dict]) -> dict:
-    """Fallback validation using SequenceMatcher when CLI is unavailable."""
+    """Fallback validation using SequenceMatcher when backend is unavailable."""
     from difflib import SequenceMatcher
 
     threshold = 0.45
@@ -170,28 +203,27 @@ def _mechanical_validate(finding: str, learnings: list[dict]) -> dict:
     if best >= 0.7:
         return {"known": True, "confidence": best, "matching_learnings": top,
                 "recommendation": f"KNOWN issue (learning #{top[0]['id']})"}
-    elif best >= 0.55:
+    if best >= 0.55:
         return {"known": True, "confidence": best, "matching_learnings": top,
                 "recommendation": f"LIKELY KNOWN (learning #{top[0]['id']})"}
-    else:
-        return {"known": False, "confidence": best, "matching_learnings": top,
-                "recommendation": "POSSIBLY RELATED but different enough to report"}
+    return {"known": False, "confidence": best, "matching_learnings": top,
+            "recommendation": "POSSIBLY RELATED but different enough to report"}
 
 
 def _extract_keywords(text: str) -> set:
     """Extract meaningful keywords from text."""
     stop_words = {
-        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-        'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
-        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
-        'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either',
-        'error', 'critical', 'warning', 'bug', 'issue', 'problem', 'fix',
-        'el', 'la', 'los', 'las', 'un', 'una', 'de', 'en', 'que', 'por',
+        "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+        "have", "has", "had", "do", "does", "did", "will", "would", "could",
+        "should", "may", "might", "must", "shall", "can", "need", "dare",
+        "to", "of", "in", "for", "on", "with", "at", "by", "from", "as",
+        "and", "but", "or", "nor", "not", "so", "yet", "both", "either",
+        "error", "critical", "warning", "bug", "issue", "problem", "fix",
+        "el", "la", "los", "las", "un", "una", "de", "en", "que", "por",
     }
     words = set()
     for word in text.lower().split():
-        clean = ''.join(c for c in word if c.isalnum() or c == '_')
+        clean = "".join(c for c in word if c.isalnum() or c == "_")
         if clean and len(clean) > 2 and clean not in stop_words:
             words.add(clean)
     return words
@@ -208,16 +240,16 @@ def main():
     result = validate_finding(args.finding, args.category)
 
     if args.json:
-        print(json.dumps(result, indent=2))
+        print(json.dumps(result, indent=2, ensure_ascii=False))
     else:
         status = "KNOWN" if result["known"] else "NEW"
         print(f"Status: {status} (confidence: {result['confidence']:.0%})")
         print(f"Recommendation: {result['recommendation']}")
         if result["matching_learnings"]:
-            print(f"Related learnings:")
-            for m in result["matching_learnings"]:
-                cat = m.get('category', '?')
-                print(f"  #{m['id']} [{cat}] {m['title']} ({m['similarity']:.0%})")
+            print("Related learnings:")
+            for match in result["matching_learnings"]:
+                cat = match.get("category", "?")
+                print(f"  #{match['id']} [{cat}] {match['title']} ({match['similarity']:.0%})")
 
     sys.exit(1 if result["known"] else 0)
 

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

@@ -6,12 +6,12 @@ Before: 595 lines of word-overlap at 50% to detect "patterns".
 Now: Collects data, passes them to CLI which UNDERSTANDS what it reads.
 
 Runs daily at 23:30 via LaunchAgent. Reads session diaries from today,
-passes them to Claude CLI (opus) which decides what deserves permanent memory.
+passes them to the configured automation backend, which decides what deserves permanent memory.
 
 Stage 1 — Data collection (Pure Python):
   Query session diaries, existing feedbacks, history.
 
-Stage 2 — Intelligence (Claude CLI opus):
+Stage 2 — Intelligence (automation backend):
   Read diaries, understand patterns, decide what to promote.
 
 Stage 3 — Sensory Register + Force analysis (Pure Python):
@@ -36,6 +36,8 @@ _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))
 
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 # Memory directory — adjust to match your project's memory location
 MEMORY_DIR = NEXO_HOME / "memory"
@@ -126,7 +128,7 @@ def collect_data() -> dict:
     return data
 
 
-# ─── Stage 2: Intelligence (Claude CLI opus) ────────────────────────────────
+# ─── Stage 2: Intelligence (automation backend) ─────────────────────────────
 
 def consolidate_with_cli(data: dict) -> bool:
     """The brain consolidates — CLI decides what to promote."""
@@ -206,18 +208,14 @@ 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)
-
+    log(f"Stage 2: Invoking automation backend with {len(diaries_with_critique)} critiques...")
     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:
@@ -230,6 +228,9 @@ Execute without asking."""
             log(f"Stage 2 output tail: {result.stdout[-500:]}")
         return True
 
+    except AutomationBackendUnavailableError as e:
+        log(f"Stage 2: automation backend unavailable: {e}")
+        return False
     except subprocess.TimeoutExpired:
         log("Stage 2: CLI timed out (300s)")
         return False