nexo-brain 2.6.11 → 2.6.13

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/schedule.py

@@ -56,21 +56,20 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
 
 def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
                         interval_seconds: int = 0, description: str = '',
-                        script_type: str = 'auto') -> str:
+                        script_type: str = 'auto', keep_alive: bool = False) -> str:
     """Add a new personal cron job. Generates and installs the LaunchAgent (macOS) or systemd timer (Linux).
 
     Args:
         cron_id: Unique ID for this cron (e.g. 'my-backup', 'report-daily'). Must be lowercase with hyphens.
         script: Path to the script to run (absolute or relative to NEXO_HOME/scripts/).
         schedule: Time-based schedule as 'HH:MM' (daily) or 'HH:MM:weekday' (e.g. '08:00:1' for Monday 8AM). Mutually exclusive with interval_seconds.
-        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule.
+        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule/keep_alive.
         description: What this cron does (for logs and status).
         script_type: 'auto' (default), 'python', 'shell', 'node', or 'php'.
+        keep_alive: Run as a daemon/keep-alive service instead of a timer.
     """
     if not cron_id or not script:
         return "ERROR: cron_id and script are required."
-    if not schedule and not interval_seconds:
-        return "ERROR: either schedule (e.g. '08:00') or interval_seconds (e.g. 300) is required."
 
     nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
     script_path = Path(script)
@@ -82,6 +81,11 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
     script_meta = parse_inline_metadata(script_path)
     detected_runtime = classify_runtime(script_path, script_meta)
     declared = get_declared_schedule(script_meta, script_meta.get("name", script_path.stem))
+    keep_alive = bool(keep_alive or declared.get("schedule_type") == "keep_alive")
+
+    if sum(bool(value) for value in [schedule, interval_seconds, keep_alive]) != 1:
+        return "ERROR: choose exactly one schedule mode: schedule, interval_seconds, or keep_alive."
+
     script_type = (script_type or "auto").strip().lower()
     if script_type == "auto":
         script_type = detected_runtime if detected_runtime != "unknown" else "python"
@@ -102,6 +106,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     elif system == "Linux":
@@ -114,6 +119,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     else:
@@ -134,7 +140,7 @@ def _runtime_command(script_type: str) -> str:
     return "python3"
 
 
-def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path=""):
+def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path="", keep_alive: bool = False):
     init_db()
     script_meta = parse_inline_metadata(Path(script_path))
     runtime = classify_runtime(Path(script_path), script_meta)
@@ -148,7 +154,11 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
         source="filesystem",
         has_inline_metadata=bool(script_meta),
     )
-    if interval_seconds:
+    if keep_alive:
+        schedule_type = "keep_alive"
+        schedule_value = "true"
+        schedule_label = "keep alive"
+    elif interval_seconds:
         schedule_type = "interval"
         schedule_value = str(interval_seconds)
         schedule_label = f"every {interval_seconds}s"
@@ -174,7 +184,7 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
 
 
 def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                     description, script_type, nexo_home, *, declared: dict | None = None):
+                     description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and load a macOS LaunchAgent."""
     import plistlib
 
@@ -201,7 +211,9 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         },
     }
 
-    if interval_seconds:
+    if keep_alive:
+        plist["KeepAlive"] = True
+    elif interval_seconds:
         plist["StartInterval"] = interval_seconds
     elif schedule:
         parts = schedule.split(":")
@@ -211,7 +223,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         plist["StartCalendarInterval"] = cal
 
     declared = declared or {}
-    if declared.get("run_on_boot"):
+    if declared.get("run_on_boot") or (keep_alive and "run_on_boot" not in declared):
         plist["RunAtLoad"] = True
 
     with open(plist_path, "wb") as f:
@@ -228,13 +240,20 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         script_type,
         label=label,
         plist_path=str(plist_path),
+        keep_alive=keep_alive,
     )
 
-    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{' Schedule: ' + schedule if schedule else f' Interval: {interval_seconds}s'}"
+    if keep_alive:
+        detail = " KeepAlive daemon"
+    elif schedule:
+        detail = f" Schedule: {schedule}"
+    else:
+        detail = f" Interval: {interval_seconds}s"
+    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{detail}"
 
 
 def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                       description, script_type, nexo_home, *, declared: dict | None = None):
+                       description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and enable a systemd user timer (Linux)."""
     unit_dir = Path.home() / ".config" / "systemd" / "user"
     unit_dir.mkdir(parents=True, exist_ok=True)
@@ -257,9 +276,46 @@ Environment=NEXO_PERSONAL_CRON_ID={cron_id}
     service_path = unit_dir / f"nexo-{cron_id}.service"
     service_path.write_text(service_content)
 
-    # Timer unit
     declared = declared or {}
 
+    if keep_alive:
+        service_content = f"""[Unit]
+Description=NEXO daemon: {description or cron_id}
+
+[Service]
+Type=simple
+ExecStart={exec_cmd}
+Restart=always
+RestartSec=10
+Environment=NEXO_HOME={nexo_home}
+Environment=HOME={Path.home()}
+Environment={PERSONAL_SCHEDULE_MANAGED_ENV}=1
+Environment=NEXO_PERSONAL_CRON_ID={cron_id}
+
+[Install]
+WantedBy=default.target
+"""
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        service_path.write_text(service_content)
+
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        subprocess.run(["systemctl", "--user", "enable", "--now", f"nexo-{cron_id}.service"], capture_output=True)
+
+        _register_schedule_metadata(
+            cron_id,
+            script_path,
+            schedule,
+            interval_seconds,
+            description,
+            script_type,
+            label=f"nexo-{cron_id}",
+            plist_path="",
+            keep_alive=True,
+        )
+
+        return f"Cron '{cron_id}' installed as KeepAlive systemd service and enabled. Service: {service_path}"
+
+    # Timer unit
     if interval_seconds:
         timer_spec = f"OnUnitActiveSec={interval_seconds}s"
         if declared.get("run_on_boot") or not declared.get("required"):
@@ -301,6 +357,7 @@ WantedBy=timers.target
         script_type,
         label=f"nexo-{cron_id}",
         plist_path="",
+        keep_alive=False,
     )
 
     return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"

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/script_registry.py

@@ -32,6 +32,16 @@ _IGNORED_FILES = {
 }
 _IGNORED_DIRS = {"deep-sleep", "__pycache__"}
 
+_LEGACY_WAKE_RECOVERY_METADATA = [
+    "# nexo: name=nexo-wake-recovery",
+    "# nexo: description=Recover interval LaunchAgents after macOS sleep/wake gaps",
+    "# nexo: runtime=shell",
+    "# nexo: cron_id=wake-recovery",
+    "# nexo: schedule_required=true",
+    "# nexo: recovery_policy=restart_daemon",
+    "# nexo: run_on_boot=true",
+]
+
 # Forbidden patterns — direct DB access from personal scripts
 _FORBIDDEN_PATTERNS = [
     re.compile(r"\bsqlite3\b"),
@@ -77,6 +87,33 @@ def get_scripts_dir() -> Path:
     return NEXO_HOME / "scripts"
 
 
+def _apply_legacy_personal_script_backfills() -> None:
+    """Backfill metadata for known legacy personal scripts shipped before the registry existed."""
+    scripts_dir = get_scripts_dir()
+    wake_recovery = scripts_dir / "nexo-wake-recovery.sh"
+    if not wake_recovery.is_file():
+        return
+
+    try:
+        text = wake_recovery.read_text()
+    except Exception:
+        return
+
+    if "# nexo:" in "\n".join(text.splitlines()[:25]):
+        return
+    if "Wake Recovery" not in text:
+        return
+
+    lines = text.splitlines(keepends=True)
+    head: list[str] = []
+    start = 0
+    if lines and lines[0].startswith("#!"):
+        head.append(lines[0])
+        start = 1
+    head.extend([line + "\n" for line in _LEGACY_WAKE_RECOVERY_METADATA])
+    wake_recovery.write_text("".join(head + lines[start:]))
+
+
 def load_core_script_names() -> set[str]:
     """Load script names from crons/manifest.json (these are core, not personal)."""
     names: set[str] = set()
@@ -279,6 +316,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
                 "cron_id": cron_id,
             }
 
+    def _effective_run_on_boot(policy: str) -> bool:
+        if "run_on_boot" in metadata:
+            return run_on_boot
+        return policy == "restart_daemon"
+
     def _effective_run_on_wake(policy: str) -> bool:
         if "run_on_wake" in metadata:
             return run_on_wake
@@ -379,12 +421,29 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "schedule": schedule_raw,
             "interval_seconds": 0,
             "recovery_policy": recovery_policy_raw or "catchup",
-            "run_on_boot": run_on_boot,
+            "run_on_boot": _effective_run_on_boot(recovery_policy_raw or "catchup"),
             "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "catchup"),
             "idempotent": _effective_idempotent(recovery_policy_raw or "catchup"),
             "max_catchup_age": max_catchup_age or (14 * 86400 if weekday is not None else 48 * 3600),
         }
 
+    if required and recovery_policy_raw == "restart_daemon":
+        return {
+            "required": required,
+            "valid": True,
+            "cron_id": cron_id,
+            "schedule_type": "keep_alive",
+            "schedule_value": "true",
+            "schedule_label": "keep alive",
+            "schedule": "",
+            "interval_seconds": 0,
+            "recovery_policy": "restart_daemon",
+            "run_on_boot": _effective_run_on_boot("restart_daemon"),
+            "run_on_wake": _effective_run_on_wake("restart_daemon"),
+            "idempotent": _effective_idempotent("restart_daemon"),
+            "max_catchup_age": max_catchup_age,
+        }
+
     return {
         "required": required,
         "valid": not required,
@@ -416,6 +475,7 @@ def _script_entry(path: Path, meta: dict, *, is_core: bool, classification: str,
 
 def classify_scripts_dir() -> dict:
     """Classify every file in NEXO_HOME/scripts into personal/core/ignored/non-script buckets."""
+    _apply_legacy_personal_script_backfills()
     scripts_dir = get_scripts_dir()
     if not scripts_dir.is_dir():
         return {"scripts_dir": str(scripts_dir), "entries": [], "summary": {}}
@@ -927,6 +987,7 @@ def ensure_personal_schedules(*, dry_run: bool = False) -> dict:
             interval_seconds=declared.get("interval_seconds", 0),
             description=script.get("description", ""),
             script_type=script.get("runtime", "auto"),
+            keep_alive=declared.get("schedule_type") == "keep_alive",
         )
         target = report["repaired" if existing else "created"]
         target.append({