nexo-brain 2.6.11 → 2.6.12

package/src/doctor/providers/runtime.py

@@ -11,6 +11,11 @@ import sys
 import time
 from pathlib import Path
 
+from client_preferences import (
+    detect_installed_clients,
+    normalize_client_preferences,
+    resolve_client_runtime_profile,
+)
 from cron_recovery import should_run_at_load
 from doctor.models import DoctorCheck
 
@@ -31,6 +36,7 @@ DEFAULT_CRON_THRESHOLD = 7200  # Fallback when manifest data is unavailable
 SPECIAL_LAUNCHAGENT_IDS = {"prevent-sleep", "tcc-approve"}
 SPECIAL_ENV_NORMALIZE_IDS = SPECIAL_LAUNCHAGENT_IDS
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
+SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
 
 
 def _file_age_seconds(path: Path) -> float | None:
@@ -90,6 +96,14 @@ def _enabled_manifest_crons() -> list[dict]:
         NEXO_CODE / "crons" / "manifest.json",
     ]
     optionals = _enabled_optionals()
+    automation_default = True
+    try:
+        if SCHEDULE_FILE.is_file():
+            schedule = _load_json(SCHEDULE_FILE)
+            if isinstance(schedule, dict):
+                automation_default = bool(schedule.get("automation_enabled", True))
+    except Exception:
+        pass
     for manifest_path in manifest_candidates:
         if not manifest_path.is_file():
             continue
@@ -104,7 +118,11 @@ def _enabled_manifest_crons() -> list[dict]:
             if not cron_id:
                 continue
             optional_key = cron.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
             enabled.append(cron)
         return enabled
@@ -875,6 +893,95 @@ def check_personal_script_registry(fix: bool = False) -> DoctorCheck:
     )
 
 
+def check_client_backend_preferences() -> DoctorCheck:
+    schedule = {}
+    try:
+        if SCHEDULE_FILE.is_file():
+            schedule = _load_json(SCHEDULE_FILE)
+    except Exception:
+        schedule = {}
+
+    prefs = normalize_client_preferences(schedule)
+    detected = detect_installed_clients()
+
+    default_terminal = prefs["default_terminal_client"]
+    automation_enabled = bool(prefs["automation_enabled"])
+    automation_backend = prefs["automation_backend"]
+    default_profile = resolve_client_runtime_profile(default_terminal, preferences=prefs)
+    automation_profile = (
+        resolve_client_runtime_profile(automation_backend, preferences=prefs)
+        if automation_enabled and automation_backend != "none"
+        else {"model": "", "reasoning_effort": ""}
+    )
+
+    evidence: list[str] = []
+    repair_plan: list[str] = []
+    severity = "info"
+    status = "healthy"
+
+    default_info = detected.get(default_terminal, {})
+    if not default_info.get("installed"):
+        status = "degraded"
+        severity = "warn"
+        evidence.append(f"default terminal client `{default_terminal}` is selected but not installed")
+        repair_plan.append(f"Install {default_terminal} or switch the default terminal client in schedule.json")
+
+    for client_key, enabled in prefs.get("interactive_clients", {}).items():
+        if not enabled:
+            continue
+        info = detected.get(client_key, {})
+        if not info.get("installed"):
+            status = "degraded"
+            severity = "warn"
+            evidence.append(f"interactive client `{client_key}` is enabled but not installed")
+
+    if automation_enabled:
+        backend_info = detected.get(automation_backend, {})
+        if automation_backend == "none":
+            status = "degraded"
+            severity = "warn"
+            evidence.append("automation is enabled but no automation backend is configured")
+        elif not backend_info.get("installed"):
+            status = "degraded"
+            severity = "warn"
+            evidence.append(f"automation backend `{automation_backend}` is enabled but not installed")
+            repair_plan.append(f"Install {automation_backend} or disable automation in schedule.json")
+
+    if not repair_plan and status != "healthy":
+        repair_plan.append("Run `nexo update` or `nexo clients sync` after installing the selected client/backend")
+
+    def _profile_label(client_key: str, profile: dict[str, str]) -> str:
+        bits = [client_key]
+        if profile.get("model"):
+            bits.append(profile["model"])
+        if profile.get("reasoning_effort"):
+            bits.append(profile["reasoning_effort"])
+        return "/".join(bits)
+
+    terminal_label = f"chat={_profile_label(default_terminal, default_profile)}"
+    automation_label = (
+        f"automation={_profile_label(automation_backend, automation_profile)}"
+        if automation_enabled and automation_backend != "none"
+        else "automation=none"
+    )
+    return DoctorCheck(
+        id="runtime.clients",
+        tier="runtime",
+        status=status,
+        severity=severity,
+        summary=f"Client/backend preferences OK ({terminal_label}, {automation_label})" if status == "healthy" else f"Client/backend preferences need attention ({terminal_label}, {automation_label})",
+        evidence=evidence or [
+            f"default terminal client: {_profile_label(default_terminal, default_profile)}",
+            f"automation backend: {_profile_label(automation_backend, automation_profile) if automation_enabled and automation_backend != 'none' else 'none'}",
+        ],
+        repair_plan=repair_plan,
+        escalation_prompt=(
+            "The configured interactive client or automation backend is missing. "
+            "Align installed clients with schedule.json so `nexo chat` and background automation use the intended tools."
+        ) if status != "healthy" else "",
+    )
+
+
 def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
     return [
@@ -882,6 +989,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         check_watchdog_status(),
         check_stale_sessions(),
         check_cron_freshness(),
+        check_client_backend_preferences(),
         check_launchagent_integrity(fix=fix),
         check_personal_script_registry(fix=fix),
         check_skill_health(fix=fix),

package/src/plugins/update.py

@@ -588,11 +588,15 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
         try:
             _emit_progress(progress_fn, "Refreshing shared client configs...")
             from client_sync import sync_all_clients
+            from client_preferences import normalize_client_preferences
 
+            schedule_path = NEXO_HOME / "config" / "schedule.json"
+            schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
             client_sync_result = sync_all_clients(
                 nexo_home=NEXO_HOME,
                 runtime_root=SRC_DIR,
                 operator_name=os.environ.get("NEXO_NAME", ""),
+                preferences=normalize_client_preferences(schedule_payload),
             )
             if client_sync_result.get("ok"):
                 steps_done.append("client-sync")
@@ -619,7 +623,7 @@ def handle_update(remote: str = "origin", branch: str = "main", progress_fn=None
         if "hook-sync" in steps_done:
             lines.append("  Hooks: synced to NEXO_HOME")
         if "client-sync" in steps_done:
-            lines.append("  Clients: Claude Code/Desktop/Codex synced")
+            lines.append("  Clients: configured client targets synced")
         lines.append("")
         lines.append("MCP server restart needed to load new code.")
         return "\n".join(lines)

package/src/runtime_power.py

@@ -71,6 +71,29 @@ def _schedule_defaults() -> dict:
     return {
         "timezone": "UTC",
         "auto_update": True,
+        "interactive_clients": {
+            "claude_code": True,
+            "codex": False,
+            "claude_desktop": False,
+        },
+        "default_terminal_client": "claude_code",
+        "automation_enabled": True,
+        "automation_backend": "claude_code",
+        "client_runtime_profiles": {
+            "claude_code": {
+                "model": "opus",
+                "reasoning_effort": "",
+            },
+            "codex": {
+                "model": "gpt-5.4",
+                "reasoning_effort": "xhigh",
+            },
+        },
+        "client_install_preferences": {
+            "claude_code": "ask",
+            "codex": "ask",
+            "claude_desktop": "manual",
+        },
         POWER_POLICY_KEY: POWER_POLICY_UNSET,
         POWER_POLICY_VERSION_KEY: POWER_POLICY_VERSION,
         FULL_DISK_ACCESS_STATUS_KEY: FULL_DISK_ACCESS_UNSET,

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