nexo-brain 2.6.11 → 2.6.13

package/src/scripts/check-context.py

@@ -2,37 +2,42 @@
 """Context checker for NEXO operations - prevents duplicate actions.
 
 Mechanical checks (email sent, file exists, action done) run in Python.
-When the 'smart' command is used, passes context to Claude CLI for
-intelligent duplicate/conflict detection that goes beyond file checks.
+When the 'smart' command is used, NEXO asks the configured automation backend
+for semantic duplicate/conflict detection that goes beyond file checks.
 """
 
+from __future__ import annotations
+
+import hashlib
+import json
 import os
 import sys
-import json
-import hashlib
-import subprocess
 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[1])))
+if str(NEXO_CODE) not in sys.path:
+    sys.path.insert(0, str(NEXO_CODE))
+
+from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
 
 class ContextChecker:
     def __init__(self):
-        self.state_dir = NEXO_HOME / 'state'
+        self.state_dir = NEXO_HOME / "state"
         self.state_dir.mkdir(exist_ok=True)
-        
+
     def check_email_sent(self, to_addr, subject, since_hours=72):
         """Check if email was already sent to address with subject."""
-        sent_path = Path.home() / 'mail' / '.nexo-sent' / '.Sent'  # Configure for your mail setup
+        sent_path = Path.home() / "mail" / ".nexo-sent" / ".Sent"
         if not sent_path.exists():
             return False
 
         subject_lower = subject.lower()
         to_lower = to_addr.lower()
         cutoff = datetime.now().timestamp() - (since_hours * 3600)
-        cur_dir = sent_path / 'cur'
+        cur_dir = sent_path / "cur"
         if not cur_dir.exists():
             return False
 
@@ -40,7 +45,7 @@ class ContextChecker:
             try:
                 if msg_file.stat().st_mtime < cutoff:
                     continue
-                content = msg_file.read_text(errors='ignore')
+                content = msg_file.read_text(errors="ignore")
             except (OSError, UnicodeDecodeError):
                 continue
 
@@ -49,16 +54,16 @@ class ContextChecker:
                 if subject_lower in content_lower:
                     return True
         return False
-        
+
     def check_file_exists(self, pattern, search_dirs=None):
         """Check if file matching pattern exists in common locations."""
         if search_dirs is None:
             search_dirs = [
-                '/var/www/vhosts',
+                "/var/www/vhosts",
                 str(NEXO_HOME),
-                '/opt'
+                "/opt",
             ]
-            
+
         for base_dir in search_dirs:
             if not os.path.exists(base_dir):
                 continue
@@ -73,83 +78,92 @@ class ContextChecker:
             except OSError:
                 continue
         return []
-        
+
     def check_action_done(self, action_type, identifier, ttl_days=7):
         """Check if action was already performed recently."""
-        action_file = self.state_dir / 'actions.json'
-        
-        # Load existing actions
+        action_file = self.state_dir / "actions.json"
         actions = {}
         if action_file.exists():
-            with open(action_file) as f:
-                actions = json.load(f)
-                
-        # Create action key
+            with open(action_file) as fh:
+                actions = json.load(fh)
+
         key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
-        
-        # Check if exists and not expired
         if key in actions:
-            action_time = datetime.fromisoformat(actions[key]['timestamp'])
+            action_time = datetime.fromisoformat(actions[key]["timestamp"])
             age_days = (datetime.now() - action_time).days
             if age_days < ttl_days:
                 return True, actions[key]
-                
         return False, None
-        
+
     def mark_action_done(self, action_type, identifier, metadata=None):
         """Mark action as completed."""
-        action_file = self.state_dir / 'actions.json'
-        
-        # Load existing actions
+        action_file = self.state_dir / "actions.json"
         actions = {}
         if action_file.exists():
-            with open(action_file) as f:
-                actions = json.load(f)
-                
-        # Add new action
+            with open(action_file) as fh:
+                actions = json.load(fh)
+
         key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
         actions[key] = {
-            'type': action_type,
-            'identifier': identifier,
-            'timestamp': datetime.now().isoformat(),
-            'metadata': metadata or {}
+            "type": action_type,
+            "identifier": identifier,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {},
         }
-        
-        # Save
-        with open(action_file, 'w') as f:
-            json.dump(actions, f, indent=2)
-            
+        with open(action_file, "w") as fh:
+            json.dump(actions, fh, indent=2)
         return key
 
-def smart_check(action_description: str, context: str = "") -> dict:
-    """Use Claude CLI to intelligently check if an action would be redundant.
 
-    Goes beyond simple file/hash checks — understands intent and context
-    to detect semantic duplicates (e.g., "send welcome email" vs
-    "email onboarding message" to same person).
-    """
+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 smart_check(action_description: str, context: str = "") -> dict:
+    """Use the automation backend to check if an action would be redundant."""
     checker = ContextChecker()
 
-    # Gather mechanical context first
-    state_file = checker.state_dir / 'actions.json'
+    state_file = checker.state_dir / "actions.json"
     recent_actions = {}
     if state_file.exists():
         try:
             all_actions = json.loads(state_file.read_text())
             cutoff = datetime.now().timestamp() - (7 * 86400)
-            for k, v in all_actions.items():
+            for key, value in all_actions.items():
                 try:
-                    ts = datetime.fromisoformat(v['timestamp']).timestamp()
+                    ts = datetime.fromisoformat(value["timestamp"]).timestamp()
                     if ts > cutoff:
-                        recent_actions[k] = v
+                        recent_actions[key] = value
                 except (ValueError, KeyError):
                     pass
         except Exception:
             pass
 
-    if not CLAUDE_CLI.exists():
-        return {"redundant": False, "reason": "CLI unavailable, cannot smart-check"}
-
     prompt = f"""You are a context deduplication engine for NEXO operations.
 
 PROPOSED ACTION:
@@ -159,9 +173,9 @@ ADDITIONAL CONTEXT:
 {context or "None"}
 
 RECENT ACTIONS (last 7 days):
-{json.dumps(list(recent_actions.values()), indent=1, default=str)}
+{json.dumps(list(recent_actions.values()), indent=1, default=str, ensure_ascii=False)}
 
-Respond with ONLY valid JSON (no markdown):
+Respond with ONLY valid JSON:
 {{
   "redundant": true/false,
   "confidence": 0.0-1.0,
@@ -172,35 +186,28 @@ Respond with ONLY valid JSON (no markdown):
 Rules:
 - Same recipient + same intent within 72h = redundant
 - Same file modification with same content = redundant
-- Similar but different scope (e.g., different recipients) = NOT redundant
+- Similar but different scope (e.g. different recipients) = NOT redundant
 - When in doubt, say not redundant (false negatives are cheaper than false positives)"""
-    )
-    if auth_check.returncode != 0:
-        # CLI not authenticated, skip gracefully
-        return {"redundant": False, "reason": "CLI not authenticated — skipped analysis", "suggestion": "N/A"}
-
-    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=300,
+            output_format="text",
+            append_system_prompt="Return exactly one valid JSON object.",
+            allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
         )
         if result.returncode == 0:
-            text = result.stdout.strip()
-            if "```json" in text:
-                text = text.split("```json")[1].split("```")[0]
-            elif "```" in text:
-                text = text.split("```")[1].split("```")[0]
-            return json.loads(text.strip())
+            parsed = _extract_json(result.stdout)
+            if parsed:
+                return parsed
+    except AutomationBackendUnavailableError as exc:
+        return {"redundant": False, "reason": f"Automation backend unavailable — {exc}"}
     except Exception:
         pass
 
-    return {"redundant": False, "reason": "CLI check failed, defaulting to not redundant"}
+    return {"redundant": False, "reason": "Automation check failed, defaulting to not redundant"}
 
 
 def main():
@@ -211,13 +218,13 @@ def main():
         print("  email <to> <subject>       - Check if email was sent")
         print("  file <pattern>             - Check if file exists")
         print("  action <type> <id>         - Check if action was done")
-        print("  smart <description> [ctx]  - Intelligent duplicate check via CLI")
+        print("  smart <description> [ctx]  - Intelligent duplicate check via automation backend")
         sys.exit(1)
 
     checker = ContextChecker()
     command = sys.argv[1]
 
-    if command == 'email':
+    if command == "email":
         if len(sys.argv) < 4:
             print("Usage: check-context.py email <to> <subject>")
             sys.exit(1)
@@ -225,16 +232,15 @@ def main():
         print("EXISTS" if exists else "NOT_FOUND")
         sys.exit(0 if not exists else 1)
 
-    elif command == 'file':
+    if command == "file":
         files = checker.check_file_exists(sys.argv[2])
         if files:
             print("\n".join(files))
             sys.exit(1)
-        else:
-            print("NOT_FOUND")
-            sys.exit(0)
+        print("NOT_FOUND")
+        sys.exit(0)
 
-    elif command == 'action':
+    if command == "action":
         if len(sys.argv) < 4:
             print("Usage: check-context.py action <type> <id>")
             sys.exit(1)
@@ -242,23 +248,19 @@ def main():
         if done:
             print(f"DONE: {data}")
             sys.exit(1)
-        else:
-            print("NOT_DONE")
-            sys.exit(0)
+        print("NOT_DONE")
+        sys.exit(0)
 
-    elif command == 'smart':
-        if len(sys.argv) < 3:
-            print("Usage: check-context.py smart <description> [context]")
-            sys.exit(1)
+    if command == "smart":
         description = sys.argv[2]
         context = sys.argv[3] if len(sys.argv) > 3 else ""
         result = smart_check(description, context)
-        print(json.dumps(result, indent=2))
+        print(json.dumps(result, indent=2, ensure_ascii=False))
         sys.exit(1 if result.get("redundant") else 0)
 
-    else:
-        print(f"Unknown command: {command}")
-        sys.exit(1)
+    print(f"Unknown command: {command}")
+    sys.exit(1)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

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())