nexo-brain 2.6.11 → 2.6.13

package/src/client_preferences.py

@@ -0,0 +1,394 @@
+from __future__ import annotations
+
+"""Client and automation preference helpers stored in config/schedule.json."""
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from runtime_power import load_schedule_config, save_schedule_config
+
+
+CLIENT_CLAUDE_CODE = "claude_code"
+CLIENT_CODEX = "codex"
+CLIENT_CLAUDE_DESKTOP = "claude_desktop"
+BACKEND_NONE = "none"
+
+INTERACTIVE_CLIENT_KEYS = (
+    CLIENT_CLAUDE_CODE,
+    CLIENT_CODEX,
+    CLIENT_CLAUDE_DESKTOP,
+)
+TERMINAL_CLIENT_KEYS = (
+    CLIENT_CLAUDE_CODE,
+    CLIENT_CODEX,
+)
+AUTOMATION_BACKEND_KEYS = (
+    BACKEND_NONE,
+    CLIENT_CLAUDE_CODE,
+    CLIENT_CODEX,
+)
+INSTALL_PREFERENCE_KEYS = {
+    "ask",
+    "auto",
+    "skip",
+    "manual",
+}
+DEFAULT_CLIENT_RUNTIME_PROFILES = {
+    CLIENT_CLAUDE_CODE: {
+        "model": "opus",
+        "reasoning_effort": "",
+    },
+    CLIENT_CODEX: {
+        "model": "gpt-5.4",
+        "reasoning_effort": "xhigh",
+    },
+}
+
+
+def _user_home() -> Path:
+    return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
+
+
+def _coerce_bool(value, default: bool) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    candidate = str(value).strip().lower()
+    if candidate in {"1", "true", "yes", "y", "on", "enabled"}:
+        return True
+    if candidate in {"0", "false", "no", "n", "off", "disabled"}:
+        return False
+    return default
+
+
+def default_client_preferences() -> dict:
+    return {
+        "interactive_clients": {
+            CLIENT_CLAUDE_CODE: True,
+            CLIENT_CODEX: False,
+            CLIENT_CLAUDE_DESKTOP: False,
+        },
+        "default_terminal_client": CLIENT_CLAUDE_CODE,
+        "automation_enabled": True,
+        "automation_backend": CLIENT_CLAUDE_CODE,
+        "client_runtime_profiles": default_client_runtime_profiles(),
+        "client_install_preferences": {
+            CLIENT_CLAUDE_CODE: "ask",
+            CLIENT_CODEX: "ask",
+            CLIENT_CLAUDE_DESKTOP: "manual",
+        },
+    }
+
+
+def normalize_client_key(value: str | None) -> str:
+    candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+    aliases = {
+        "claude": CLIENT_CLAUDE_CODE,
+        "claude_code": CLIENT_CLAUDE_CODE,
+        "claudecode": CLIENT_CLAUDE_CODE,
+        "claudecli": CLIENT_CLAUDE_CODE,
+        "codex": CLIENT_CODEX,
+        "openai_codex": CLIENT_CODEX,
+        "claude_desktop": CLIENT_CLAUDE_DESKTOP,
+        "claudedesktop": CLIENT_CLAUDE_DESKTOP,
+        "desktop": CLIENT_CLAUDE_DESKTOP,
+        "claude_app": CLIENT_CLAUDE_DESKTOP,
+    }
+    return aliases.get(candidate, "")
+
+
+def normalize_backend_key(value: str | None) -> str:
+    candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+    if candidate in {"", "none", "off", "disabled", "false", "0"}:
+        return BACKEND_NONE
+    client_key = normalize_client_key(candidate)
+    if client_key in TERMINAL_CLIENT_KEYS:
+        return client_key
+    return ""
+
+
+def normalize_interactive_clients(value) -> dict[str, bool]:
+    if not isinstance(value, dict):
+        return dict(default_client_preferences()["interactive_clients"])
+
+    normalized = {
+        CLIENT_CLAUDE_CODE: False,
+        CLIENT_CODEX: False,
+        CLIENT_CLAUDE_DESKTOP: False,
+    }
+
+    for raw_key, raw_value in value.items():
+        key = normalize_client_key(raw_key)
+        if key:
+            normalized[key] = _coerce_bool(raw_value, False)
+    return normalized
+
+
+def normalize_default_terminal_client(value, interactive_clients: dict[str, bool] | None = None) -> str:
+    interactive_clients = normalize_interactive_clients(interactive_clients or {})
+    candidate = normalize_client_key(value)
+    if candidate in TERMINAL_CLIENT_KEYS and interactive_clients.get(candidate, False):
+        return candidate
+    for terminal_client in TERMINAL_CLIENT_KEYS:
+        if interactive_clients.get(terminal_client, False):
+            return terminal_client
+    return CLIENT_CLAUDE_CODE
+
+
+def normalize_automation_enabled(value) -> bool:
+    return _coerce_bool(value, True)
+
+
+def normalize_automation_backend(value, *, automation_enabled: bool = True) -> str:
+    if not automation_enabled:
+        return BACKEND_NONE
+    candidate = normalize_backend_key(value)
+    if candidate in TERMINAL_CLIENT_KEYS:
+        return candidate
+    return CLIENT_CLAUDE_CODE
+
+
+def normalize_client_install_preferences(value) -> dict[str, str]:
+    defaults = default_client_preferences()["client_install_preferences"]
+    normalized = dict(defaults)
+    if not isinstance(value, dict):
+        return normalized
+    for raw_key, raw_value in value.items():
+        key = normalize_client_key(raw_key)
+        pref = str(raw_value or "").strip().lower()
+        if key and pref in INSTALL_PREFERENCE_KEYS:
+            normalized[key] = pref
+    return normalized
+
+
+def default_client_runtime_profiles() -> dict[str, dict[str, str]]:
+    return {
+        client_key: dict(profile)
+        for client_key, profile in DEFAULT_CLIENT_RUNTIME_PROFILES.items()
+    }
+
+
+def _normalize_runtime_model(value, *, default: str) -> str:
+    candidate = str(value or "").strip()
+    return candidate or default
+
+
+def _normalize_runtime_reasoning_effort(value, *, default: str) -> str:
+    candidate = str(value or "").strip().lower()
+    return candidate or default
+
+
+def normalize_client_runtime_profiles(value) -> dict[str, dict[str, str]]:
+    defaults = default_client_runtime_profiles()
+    normalized = default_client_runtime_profiles()
+    if not isinstance(value, dict):
+        return normalized
+
+    for raw_client, raw_profile in value.items():
+        client_key = normalize_client_key(raw_client)
+        if client_key not in TERMINAL_CLIENT_KEYS:
+            continue
+        if isinstance(raw_profile, dict):
+            normalized[client_key] = {
+                "model": _normalize_runtime_model(
+                    raw_profile.get("model"),
+                    default=defaults[client_key]["model"],
+                ),
+                "reasoning_effort": _normalize_runtime_reasoning_effort(
+                    raw_profile.get("reasoning_effort"),
+                    default=defaults[client_key]["reasoning_effort"],
+                ),
+            }
+            continue
+        normalized[client_key] = {
+            "model": _normalize_runtime_model(raw_profile, default=defaults[client_key]["model"]),
+            "reasoning_effort": defaults[client_key]["reasoning_effort"],
+        }
+    return normalized
+
+
+def normalize_client_preferences(schedule: dict | None = None) -> dict:
+    schedule = dict(schedule or {})
+    interactive_clients = normalize_interactive_clients(schedule.get("interactive_clients"))
+    automation_enabled = normalize_automation_enabled(schedule.get("automation_enabled"))
+    default_terminal_client = normalize_default_terminal_client(
+        schedule.get("default_terminal_client"),
+        interactive_clients=interactive_clients,
+    )
+    automation_backend = normalize_automation_backend(
+        schedule.get("automation_backend"),
+        automation_enabled=automation_enabled,
+    )
+    install_preferences = normalize_client_install_preferences(
+        schedule.get("client_install_preferences")
+    )
+    runtime_profiles = normalize_client_runtime_profiles(
+        schedule.get("client_runtime_profiles")
+    )
+    return {
+        "interactive_clients": interactive_clients,
+        "default_terminal_client": default_terminal_client,
+        "automation_enabled": automation_enabled,
+        "automation_backend": automation_backend,
+        "client_runtime_profiles": runtime_profiles,
+        "client_install_preferences": install_preferences,
+    }
+
+
+def apply_client_preferences(
+    schedule: dict | None = None,
+    *,
+    interactive_clients: dict | None = None,
+    default_terminal_client: str | None = None,
+    automation_enabled=None,
+    automation_backend: str | None = None,
+    client_runtime_profiles: dict | None = None,
+    client_install_preferences: dict | None = None,
+) -> dict:
+    merged = dict(schedule or {})
+    current = normalize_client_preferences(schedule)
+    merged["interactive_clients"] = normalize_interactive_clients(
+        interactive_clients if interactive_clients is not None else current["interactive_clients"]
+    )
+    merged["automation_enabled"] = normalize_automation_enabled(
+        automation_enabled if automation_enabled is not None else current["automation_enabled"]
+    )
+    merged["default_terminal_client"] = normalize_default_terminal_client(
+        default_terminal_client if default_terminal_client is not None else current["default_terminal_client"],
+        interactive_clients=merged["interactive_clients"],
+    )
+    merged["automation_backend"] = normalize_automation_backend(
+        automation_backend if automation_backend is not None else current["automation_backend"],
+        automation_enabled=merged["automation_enabled"],
+    )
+    merged["client_runtime_profiles"] = normalize_client_runtime_profiles(
+        client_runtime_profiles
+        if client_runtime_profiles is not None
+        else current["client_runtime_profiles"]
+    )
+    merged["client_install_preferences"] = normalize_client_install_preferences(
+        client_install_preferences
+        if client_install_preferences is not None
+        else current["client_install_preferences"]
+    )
+    return merged
+
+
+def load_client_preferences() -> dict:
+    return normalize_client_preferences(load_schedule_config())
+
+
+def save_client_preferences(
+    *,
+    interactive_clients: dict | None = None,
+    default_terminal_client: str | None = None,
+    automation_enabled=None,
+    automation_backend: str | None = None,
+    client_runtime_profiles: dict | None = None,
+    client_install_preferences: dict | None = None,
+) -> Path:
+    schedule = apply_client_preferences(
+        load_schedule_config(),
+        interactive_clients=interactive_clients,
+        default_terminal_client=default_terminal_client,
+        automation_enabled=automation_enabled,
+        automation_backend=automation_backend,
+        client_runtime_profiles=client_runtime_profiles,
+        client_install_preferences=client_install_preferences,
+    )
+    return save_schedule_config(schedule)
+
+
+def _claude_desktop_config_path(home: Path) -> Path:
+    if sys.platform == "darwin":
+        return home / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+    if os.name == "nt":
+        return home / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
+    return home / ".config" / "Claude" / "claude_desktop_config.json"
+
+
+def detect_installed_clients(user_home: str | os.PathLike[str] | None = None) -> dict[str, dict]:
+    home = Path(user_home).expanduser() if user_home else _user_home()
+
+    claude_bin = os.environ.get("CLAUDE_BIN", "").strip() or shutil.which("claude") or ""
+    codex_bin = os.environ.get("CODEX_BIN", "").strip() or shutil.which("codex") or ""
+
+    if sys.platform == "darwin":
+        desktop_app = next(
+            (
+                str(candidate)
+                for candidate in (
+                    home / "Applications" / "Claude.app",
+                    Path("/Applications/Claude.app"),
+                )
+                if candidate.exists()
+            ),
+            "",
+        )
+    else:
+        desktop_app = ""
+    desktop_config = _claude_desktop_config_path(home)
+
+    return {
+        CLIENT_CLAUDE_CODE: {
+            "installed": bool(claude_bin),
+            "path": claude_bin,
+            "detected_by": "binary" if claude_bin else "missing",
+        },
+        CLIENT_CODEX: {
+            "installed": bool(codex_bin),
+            "path": codex_bin,
+            "detected_by": "binary" if codex_bin else "missing",
+        },
+        CLIENT_CLAUDE_DESKTOP: {
+            "installed": bool(desktop_app or desktop_config.exists()),
+            "path": desktop_app or str(desktop_config),
+            "detected_by": "app" if desktop_app else ("config" if desktop_config.exists() else "missing"),
+        },
+    }
+
+
+def resolve_terminal_client(requested: str | None = None, *, preferences: dict | None = None) -> str:
+    normalized = preferences or load_client_preferences()
+    if requested is not None:
+        interactive_clients = normalized["interactive_clients"]
+        return normalize_default_terminal_client(requested, interactive_clients=interactive_clients)
+    return normalize_default_terminal_client(
+        normalized["default_terminal_client"],
+        interactive_clients=normalized["interactive_clients"],
+    )
+
+
+def resolve_automation_backend(preferences: dict | None = None) -> str:
+    normalized = preferences or load_client_preferences()
+    return normalize_automation_backend(
+        normalized["automation_backend"],
+        automation_enabled=normalized["automation_enabled"],
+    )
+
+
+def resolve_client_runtime_profile(
+    client: str | None,
+    *,
+    preferences: dict | None = None,
+) -> dict[str, str]:
+    normalized = preferences or load_client_preferences()
+    client_key = normalize_client_key(client)
+    defaults = default_client_runtime_profiles()
+    if client_key not in TERMINAL_CLIENT_KEYS:
+        client_key = CLIENT_CLAUDE_CODE
+    profiles = normalize_client_runtime_profiles(normalized.get("client_runtime_profiles"))
+    profile = profiles.get(client_key) or defaults[client_key]
+    return {
+        "model": _normalize_runtime_model(
+            profile.get("model"),
+            default=defaults[client_key]["model"],
+        ),
+        "reasoning_effort": _normalize_runtime_reasoning_effort(
+            profile.get("reasoning_effort"),
+            default=defaults[client_key]["reasoning_effort"],
+        ),
+    }

package/src/client_sync.py

@@ -10,6 +10,46 @@ import subprocess
 import sys
 from pathlib import Path
 
+try:
+    from client_preferences import (
+        BACKEND_NONE,
+        INTERACTIVE_CLIENT_KEYS,
+        normalize_backend_key,
+        normalize_client_key,
+        normalize_client_preferences,
+    )
+except Exception:
+    BACKEND_NONE = "none"
+    INTERACTIVE_CLIENT_KEYS = ("claude_code", "codex", "claude_desktop")
+
+    def normalize_client_key(value: str | None) -> str:
+        candidate = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+        aliases = {
+            "claude": "claude_code",
+            "claude_code": "claude_code",
+            "codex": "codex",
+            "claude_desktop": "claude_desktop",
+            "desktop": "claude_desktop",
+        }
+        return aliases.get(candidate, "")
+
+    def normalize_backend_key(value: str | None) -> str:
+        candidate = normalize_client_key(value)
+        return candidate or (BACKEND_NONE if str(value or "").strip().lower() in {"none", "off", "disabled"} else "")
+
+    def normalize_client_preferences(schedule: dict | None = None) -> dict:
+        return {
+            "interactive_clients": {
+                "claude_code": True,
+                "codex": False,
+                "claude_desktop": False,
+            },
+            "default_terminal_client": "claude_code",
+            "automation_enabled": True,
+            "automation_backend": "claude_code",
+        }
+
+
 
 def _user_home() -> Path:
     return Path(os.environ.get("HOME", str(Path.home()))).expanduser()
@@ -252,8 +292,37 @@ def sync_all_clients(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    enabled_clients: list[str] | tuple[str, ...] | set[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
+    if enabled_clients is None:
+        if preferences is None:
+            enabled_set = set(INTERACTIVE_CLIENT_KEYS)
+        else:
+            active_preferences = normalize_client_preferences(preferences)
+            enabled_set = {
+                key
+                for key in INTERACTIVE_CLIENT_KEYS
+                if active_preferences.get("interactive_clients", {}).get(key, False)
+            }
+            backend_key = normalize_backend_key(active_preferences.get("automation_backend"))
+            if active_preferences.get("automation_enabled", True) and backend_key and backend_key != BACKEND_NONE:
+                enabled_set.add(backend_key)
+            if not enabled_set:
+                enabled_set.add("claude_code")
+    else:
+        enabled_set = {normalize_client_key(item) for item in enabled_clients if normalize_client_key(item)}
+        if not enabled_set:
+            enabled_set = {"claude_code"}
+
     def _safe(label: str, fn) -> dict:
+        if label not in enabled_set:
+            return {
+                "ok": True,
+                "client": label,
+                "skipped": True,
+                "reason": "disabled in client preferences",
+            }
         try:
             return fn(
                 nexo_home=nexo_home,
@@ -278,6 +347,7 @@ def sync_all_clients(
             Path(nexo_home).expanduser() if nexo_home else _default_nexo_home(),
             runtime_root,
         )),
+        "enabled_clients": sorted(enabled_set),
         "clients": results,
     }
 
@@ -307,6 +377,13 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--runtime-root", default="")
     parser.add_argument("--python", dest="python_path", default="")
     parser.add_argument("--operator-name", default="")
+    parser.add_argument(
+        "--enabled-client",
+        action="append",
+        dest="enabled_clients",
+        choices=["claude_code", "claude_desktop", "codex"],
+        help="Sync only the specified client(s). Repeat for multiple values.",
+    )
     parser.add_argument("--json", action="store_true")
     args = parser.parse_args(argv)
 
@@ -315,6 +392,7 @@ def main(argv: list[str] | None = None) -> int:
         runtime_root=args.runtime_root or None,
         python_path=args.python_path,
         operator_name=args.operator_name,
+        enabled_clients=args.enabled_clients,
     )
     if args.json:
         print(json.dumps(result, indent=2, ensure_ascii=False))

package/src/cron_recovery.py

@@ -13,6 +13,7 @@ NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
 LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
+SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
 DB_PATH = NEXO_HOME / "data" / "nexo.db"
 STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
 
@@ -38,6 +39,8 @@ def load_enabled_crons() -> list[dict]:
     optionals = _load_json(OPTIONALS_FILE, {})
     if not isinstance(optionals, dict):
         optionals = {}
+    schedule_data = _load_json(SCHEDULE_FILE, {})
+    automation_default = bool(schedule_data.get("automation_enabled", True)) if isinstance(schedule_data, dict) else True
 
     for manifest_path in manifest_candidates:
         if not manifest_path.is_file():
@@ -50,7 +53,11 @@ def load_enabled_crons() -> list[dict]:
         enabled = []
         for cron in data.get("crons", []):
             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(dict(cron))
         return enabled

package/src/crons/manifest.json

@@ -9,6 +9,7 @@
       "schedule": {"hour": 4, "minute": 30},
       "description": "Overnight session analysis — 4 phases: collect, extract, synthesize, apply",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 172800,
@@ -21,6 +22,7 @@
       "schedule": {"hour": 4, "minute": 0},
       "description": "Nightly memory consolidation and dream cycle",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 172800,
@@ -82,6 +84,7 @@
       "schedule": {"hour": 7, "minute": 0},
       "description": "Daily self-audit — validates learnings, protocols, drift",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 172800,
@@ -94,6 +97,7 @@
       "schedule": {"hour": 23, "minute": 30},
       "description": "Consolidate session post-mortems into patterns",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 172800,
@@ -106,6 +110,7 @@
       "schedule": {"hour": 5, "minute": 0, "weekday": 0},
       "description": "Weekly self-improvement cycle — propose and evaluate changes",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 1209600,
@@ -130,6 +135,7 @@
       "schedule": {"hour": 6, "minute": 0},
       "description": "Daily synthesis — cross-reference learnings, decisions, changes",
       "core": true,
+      "optional": "automation",
       "recovery_policy": "catchup",
       "idempotent": true,
       "max_catchup_age": 172800,

package/src/crons/sync.py

@@ -41,6 +41,7 @@ LAUNCH_AGENTS_DIR = Path.home() / "Library" / "LaunchAgents"
 LABEL_PREFIX = "com.nexo."
 LOG_DIR = NEXO_HOME / "logs"
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
+SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
 RETIRED_CORE_FILES = (
     Path("scripts") / "nexo-day-orchestrator.sh",
 )
@@ -111,10 +112,22 @@ def load_manifest() -> list[dict]:
         except Exception as e:
             log(f"WARNING: could not read optionals.json: {e}")
 
+    automation_default = True
+    if SCHEDULE_FILE.is_file():
+        try:
+            schedule_data = json.loads(SCHEDULE_FILE.read_text())
+            automation_default = bool(schedule_data.get("automation_enabled", True))
+        except Exception:
+            pass
+
     filtered = []
     for cron in crons:
         optional_key = cron.get("optional")
-        if optional_key and not enabled_optionals.get(optional_key, False):
+        if optional_key == "automation":
+            enabled = enabled_optionals.get(optional_key, automation_default)
+        else:
+            enabled = enabled_optionals.get(optional_key, False)
+        if optional_key and not enabled:
             continue
         filtered.append(cron)
     return filtered