nexo-brain 7.1.0 → 7.1.2

package/src/cli_email.py

@@ -41,7 +41,7 @@ def _prompt_int(msg: str, default: int) -> int:
         try:
             return int(raw)
         except ValueError:
-            print(f"  ✗ '{raw}' no es un número. Prueba otra vez.")
+            print(f"  ✗ '{raw}' is not a valid number. Try again.")
 
 
 def _prompt_yes_no(msg: str, default: bool = True) -> bool:
@@ -54,12 +54,12 @@ def _prompt_yes_no(msg: str, default: bool = True) -> bool:
             return True
         if raw in ("n", "no"):
             return False
-        print("  ✗ Responde y o n.")
+        print("  ✗ Answer with y or n.")
 
 
 def _mask_password(pw: str) -> str:
     if not pw:
-        return "(vacío)"
+        return "(empty)"
     if len(pw) <= 4:
         return "•" * len(pw)
     return pw[0] + "•" * (len(pw) - 2) + pw[-1]
@@ -103,61 +103,61 @@ def _delete_credential(service: str, key: str) -> None:
 def cmd_email_setup(args) -> int:
     """Interactive wizard for the primary agent mailbox."""
     print("━" * 60)
-    print("NEXO · Asistente de configuración de email")
+    print("NEXO · Email setup wizard")
     print("━" * 60)
-    print("Te voy a preguntar los datos de la cuenta de correo del agente")
-    print("que NEXO usará para leer y contestar. Si te equivocas, vuelve")
-    print("a ejecutar `nexo email setup` en cualquier momento.\n")
+    print("I will ask for the mailbox details NEXO should use to")
+    print("read and reply. If you make a mistake, just run")
+    print("`nexo email setup` again at any time.\n")
 
     from db import init_db
     from db._email_accounts import add_email_account, get_email_account
 
     init_db()
 
-    label = _prompt("Etiqueta de la cuenta (ej: 'primary', 'wazion')", "primary")
+    label = _prompt("Account label (example: 'primary', 'wazion')", "primary")
 
     existing = get_email_account(label)
     if existing:
         if not _prompt_yes_no(
-            f"Ya existe una cuenta '{label}' ({existing.get('email')}). ¿La sobrescribo?",
+            f"An account named '{label}' already exists ({existing.get('email')}). Overwrite it?",
             default=False,
         ):
-            print("Cancelado.")
+            print("Cancelled.")
             return 1
 
-    email = _prompt("Dirección email (ej: nexo@tudominio.com)")
+    email = _prompt("Email address (example: nexo@yourdomain.com)")
     if not email or "@" not in email:
-        print(f"  ✗ '{email}' no parece un email válido.")
+        print(f"  ✗ '{email}' does not look like a valid email address.")
         return 1
 
-    imap_host = _prompt("Servidor IMAP (entrada)", "imap.gmail.com")
-    imap_port = _prompt_int("Puerto IMAP", 993)
-    smtp_host = _prompt("Servidor SMTP (salida)", imap_host.replace("imap", "smtp"))
-    smtp_port = _prompt_int("Puerto SMTP", 465)
+    imap_host = _prompt("IMAP server (incoming mail)", "imap.gmail.com")
+    imap_port = _prompt_int("IMAP port", 993)
+    smtp_host = _prompt("SMTP server (outgoing mail)", imap_host.replace("imap", "smtp"))
+    smtp_port = _prompt_int("SMTP port", 465)
 
     try:
-        pwd = getpass.getpass("Contraseña (no se mostrará): ")
+        pwd = getpass.getpass("Password (hidden input): ")
     except (EOFError, KeyboardInterrupt):
-        print("\n(cancelado)")
+        print("\n(cancelled)")
         return 1
     if not pwd:
-        print("  ✗ Necesito una contraseña.")
+        print("  ✗ A password is required.")
         return 1
 
     operator_email = _prompt(
-        "Email donde NEXO te enviará el briefing matinal (tu email personal)",
+        "Operator email for the daily briefing",
         email,
     )
 
     trusted_raw = _prompt(
-        "Dominios de confianza separados por coma (puedes dejar vacío)",
+        "Trusted domains (comma-separated, optional)",
         "",
     )
     trusted = [d.strip() for d in trusted_raw.split(",") if d.strip()]
-    sent_folder = _prompt("Carpeta IMAP de enviados", "INBOX.Sent").strip() or "INBOX.Sent"
+    sent_folder = _prompt("IMAP sent folder", "INBOX.Sent").strip() or "INBOX.Sent"
 
     role = _prompt(
-        "Rol de la cuenta: inbox (solo leer) / outbox (solo enviar) / both",
+        "Account role: inbox (read only) / outbox (send only) / both",
         "both",
     )
     if role not in ("inbox", "outbox", "both"):
@@ -188,20 +188,20 @@ def cmd_email_setup(args) -> int:
     )
 
     print()
-    print("✓ Cuenta guardada:")
+    print("✓ Account saved:")
     print(f"  label:          {account.get('label')}")
     print(f"  email:          {account.get('email')}")
     print(f"  IMAP:           {account.get('imap_host')}:{account.get('imap_port')}")
     print(f"  SMTP:           {account.get('smtp_host')}:{account.get('smtp_port')}")
     print(f"  operator_email: {account.get('operator_email')}")
-    print(f"  trusted:        {account.get('trusted_domains') or '(ninguno)'}")
+    print(f"  trusted:        {account.get('trusted_domains') or '(none)'}")
     print(f"  role:           {account.get('role')}")
     print(f"  sent_folder:    {_sent_folder_from_account(account)}")
-    print(f"  password:       {_mask_password(pwd)} (guardada en credentials)")
+    print(f"  password:       {_mask_password(pwd)} (stored in credentials)")
     print()
-    if _prompt_yes_no("¿Pruebo la conexión ahora?", default=True):
+    if _prompt_yes_no("Test the connection now?", default=True):
         return cmd_email_test(type("Args", (), {"label": label})())
-    print("Puedes probarla cuando quieras con: nexo email test " + label)
+    print("You can test it later with: nexo email test " + label)
     return 0
 
 
@@ -218,11 +218,18 @@ def _account_to_public_dict(account: dict) -> dict:
     stored so the UI can show a 'no password yet' marker."""
     if not account:
         return {}
+    metadata = account.get("metadata") or {}
+    if not isinstance(metadata, dict):
+        metadata = {}
+    legacy_migrated = bool(metadata.get("migrated_from_legacy_email_config"))
     return {
+        "id": account.get("id"),
         "label": account.get("label"),
         "email": account.get("email"),
         "account_type": account.get("account_type", "agent"),
         "description": account.get("description", ""),
+        "description_source": "legacy_migration" if legacy_migrated else "",
+        "legacy_migrated": legacy_migrated,
         "imap_host": account.get("imap_host"),
         "imap_port": account.get("imap_port"),
         "smtp_host": account.get("smtp_host"),
@@ -240,6 +247,22 @@ def _account_to_public_dict(account: dict) -> dict:
     }
 
 
+def _selector_from_args(args) -> tuple[int | None, str]:
+    raw_id = getattr(args, "account_id", None)
+    label = str(getattr(args, "label", None) or getattr(args, "label_pos", None) or "").strip()
+    try:
+        account_id = int(raw_id) if raw_id not in (None, "") else None
+    except Exception:
+        account_id = None
+    if account_id is not None and account_id <= 0:
+        account_id = None
+    return account_id, label
+
+
+def _selector_usage(command: str) -> str:
+    return f"usage: nexo email {command} <label> [--id ACCOUNT_ID]"
+
+
 def cmd_email_list(args) -> int:
     from db import init_db
     from db._email_accounts import list_email_accounts
@@ -253,7 +276,7 @@ def cmd_email_list(args) -> int:
         })
         return 0
     if not accounts:
-        print("(sin cuentas configuradas — corre `nexo email setup`)")
+        print("(no accounts configured — run `nexo email setup`)")
         return 0
     print(f"{'LABEL':<18} {'TYPE':<9} {'EMAIL':<34} {'PERMS':<7} {'DEF':<4} IMAP")
     for a in accounts:
@@ -315,7 +338,7 @@ def cmd_email_add(args) -> int:
             print(f"✗ {msg}")
         return 1
     if "@" not in email:
-        msg = f"'{email}' no parece un email válido."
+        msg = f"'{email}' does not look like a valid email address."
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
@@ -443,16 +466,15 @@ def cmd_email_add(args) -> int:
     if json_mode:
         _emit_json({"ok": True, "account": public})
     else:
-        print(f"✓ Cuenta '{label}' guardada.")
+        print(f"✓ Account '{label}' saved.")
     return 0
 
 
 def cmd_email_test(args) -> int:
     json_mode = getattr(args, "json", False)
-    # Keep the legacy positional + the new --label flag both wired.
-    label = getattr(args, "label", None) or getattr(args, "label_pos", None)
-    if not label:
-        msg = "usage: nexo email test <label>"
+    account_id, label = _selector_from_args(args)
+    if account_id is None and not label:
+        msg = _selector_usage("test")
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
@@ -462,9 +484,10 @@ def cmd_email_test(args) -> int:
     from email_config import load_email_config
 
     init_db()
-    cfg = load_email_config(label=label)
+    cfg = load_email_config(label=label or None, account_id=account_id)
     if cfg is None:
-        msg = f"Cuenta '{label}' no encontrada."
+        selector = f"id={account_id}" if account_id is not None else label
+        msg = f"Account '{selector}' not found."
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
@@ -496,7 +519,8 @@ def cmd_email_test(args) -> int:
     if json_mode:
         _emit_json({
             "ok": ok_imap and ok_smtp,
-            "label": label,
+            "id": cfg.get("id"),
+            "label": cfg.get("label") or label,
             "imap": {"ok": ok_imap, "host": cfg["imap_host"], "port": cfg["imap_port"], "error": err_imap},
             "smtp": {"ok": ok_smtp, "host": cfg["smtp_host"], "port": cfg["smtp_port"], "error": err_smtp},
             "message": "Login OK" if (ok_imap and ok_smtp) else (err_imap or err_smtp or "test failed"),
@@ -515,21 +539,22 @@ def cmd_email_test(args) -> int:
 
 def cmd_email_remove(args) -> int:
     json_mode = getattr(args, "json", False)
-    label = getattr(args, "label", None) or getattr(args, "label_pos", None)
-    if not label:
-        msg = "usage: nexo email remove <label>"
+    account_id, label = _selector_from_args(args)
+    if account_id is None and not label:
+        msg = _selector_usage("remove")
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
             print(msg)
         return 1
     from db import init_db
-    from db._email_accounts import get_email_account, remove_email_account
+    from db._email_accounts import get_email_account, get_email_account_by_id, remove_email_account
 
     init_db()
-    acc = get_email_account(label)
+    acc = get_email_account_by_id(account_id) if account_id is not None else get_email_account(label)
     if not acc:
-        msg = f"Cuenta '{label}' no encontrada."
+        selector = f"id={account_id}" if account_id is not None else label
+        msg = f"Account '{selector}' not found."
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
@@ -539,53 +564,55 @@ def cmd_email_remove(args) -> int:
         if json_mode:
             _emit_json({"ok": False, "message": "missing --yes (interactive confirmation required)"})
             return 1
-        if not _prompt_yes_no(f"¿Eliminar la cuenta '{label}' ({acc.get('email')})?", default=False):
-            print("Cancelado.")
+        if not _prompt_yes_no(f"Delete account '{label}' ({acc.get('email')})?", default=False):
+            print("Cancelled.")
             return 0
     _delete_credential(acc.get("credential_service", ""), acc.get("credential_key", ""))
-    remove_email_account(label)
+    remove_email_account(account_id=acc.get("id"))
     if json_mode:
-        _emit_json({"ok": True, "label": label, "message": "removed"})
+        _emit_json({"ok": True, "id": acc.get("id"), "label": acc.get("label"), "message": "removed"})
     else:
-        print(f"✓ Cuenta '{label}' eliminada.")
+        print(f"✓ Account '{acc.get('label')}' removed.")
     return 0
 
 
 def cmd_email_set_enabled(args) -> int:
-    label = getattr(args, "label", None) or getattr(args, "label_pos", None)
+    account_id, label = _selector_from_args(args)
     json_mode = bool(getattr(args, "json", False))
     enabled = bool(getattr(args, "enabled", True))
-    if not label:
-        msg = "usage: nexo email enable|disable <label>"
+    if account_id is None and not label:
+        msg = _selector_usage("enable|disable")
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
             print(msg)
         return 1
     from db import init_db
-    from db._email_accounts import get_email_account, set_email_account_enabled
+    from db._email_accounts import get_email_account, get_email_account_by_id, set_email_account_enabled
 
     init_db()
-    acc = get_email_account(label)
+    acc = get_email_account_by_id(account_id) if account_id is not None else get_email_account(label)
     if not acc:
-        msg = f"Cuenta '{label}' no encontrada."
+        selector = f"id={account_id}" if account_id is not None else label
+        msg = f"Account '{selector}' not found."
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
             print(f"✗ {msg}")
         return 1
-    changed = set_email_account_enabled(label, enabled)
+    changed = set_email_account_enabled(account_id=acc.get("id"), enabled=enabled)
     if not changed:
-        msg = f"No se pudo actualizar la cuenta '{label}'."
+        msg = f"Could not update account '{acc.get('label')}'."
         if json_mode:
             _emit_json({"ok": False, "message": msg})
         else:
             print(f"✗ {msg}")
         return 1
-    updated = get_email_account(label) or {}
+    updated = get_email_account_by_id(acc.get("id")) or {}
     payload = {
         "ok": True,
-        "label": label,
+        "id": updated.get("id"),
+        "label": updated.get("label") or label,
         "enabled": bool(updated.get("enabled", enabled)),
         "message": "enabled" if enabled else "disabled",
     }
@@ -593,22 +620,22 @@ def cmd_email_set_enabled(args) -> int:
         _emit_json(payload)
     else:
         print(
-            f"✓ Cuenta '{label}' "
-            + ("activada." if payload["enabled"] else "desactivada.")
+            f"✓ Account '{payload['label']}' "
+            + ("enabled." if payload["enabled"] else "disabled.")
         )
     return 0
 
 
 def register_email_parser(subparsers) -> None:
     """Hook called by cli.py to add the `email` subcommand tree."""
-    p = subparsers.add_parser("email", help="Gestionar cuentas de correo NEXO")
+    p = subparsers.add_parser("email", help="Manage NEXO email accounts")
     p.set_defaults(func=lambda a: p.print_help() or 0)
     sub = p.add_subparsers(dest="email_action")
 
-    s = sub.add_parser("setup", help="Asistente interactivo para añadir / reconfigurar una cuenta")
+    s = sub.add_parser("setup", help="Interactive wizard to add or reconfigure an account")
     s.set_defaults(func=cmd_email_setup)
 
-    s = sub.add_parser("add", help="Añadir cuenta de forma no-interactiva (Desktop / scripts)")
+    s = sub.add_parser("add", help="Add an account non-interactively (Desktop / scripts)")
     s.add_argument("--label", required=True)
     s.add_argument("--email", required=True)
     s.add_argument("--imap-host", dest="imap_host", default="")
@@ -639,37 +666,41 @@ def register_email_parser(subparsers) -> None:
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_add)
 
-    s = sub.add_parser("list", help="Listar cuentas configuradas")
+    s = sub.add_parser("list", help="List configured accounts")
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_list)
 
-    s = sub.add_parser("test", help="Probar IMAP + SMTP de una cuenta")
+    s = sub.add_parser("test", help="Test IMAP + SMTP for an account")
     s.add_argument("label_pos", nargs="?", default=None,
-                   help="Etiqueta de la cuenta (legacy positional)")
+                   help="Account label (legacy positional)")
     s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_test)
 
-    s = sub.add_parser("remove", help="Eliminar una cuenta")
+    s = sub.add_parser("remove", help="Remove an account")
     s.add_argument("label_pos", nargs="?", default=None,
-                   help="Etiqueta de la cuenta (legacy positional)")
+                   help="Account label (legacy positional)")
     s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
     s.add_argument("--yes", dest="yes", action="store_true",
                    help="Skip the interactive confirmation (required for --json).")
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_remove)
 
-    s = sub.add_parser("enable", help="Activar una cuenta sin borrarla")
+    s = sub.add_parser("enable", help="Enable an account without deleting it")
     s.add_argument("label_pos", nargs="?", default=None,
-                   help="Etiqueta de la cuenta (legacy positional)")
+                   help="Account label (legacy positional)")
     s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_set_enabled, enabled=True)
 
-    s = sub.add_parser("disable", help="Desactivar una cuenta sin borrarla")
+    s = sub.add_parser("disable", help="Disable an account without deleting it")
     s.add_argument("label_pos", nargs="?", default=None,
-                   help="Etiqueta de la cuenta (legacy positional)")
+                   help="Account label (legacy positional)")
     s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_set_enabled, enabled=False)
 

package/src/client_sync.py

@@ -78,6 +78,7 @@ except Exception:
 
 
 CLAUDE_CODE_NPM_PACKAGE = "@anthropic-ai/claude-code"
+DEFAULT_ASSISTANT_NAME = "Nova"
 HOOK_TIMEOUTS_BY_EVENT = {
     "SessionStart": 40,
     "Stop": 15,
@@ -99,6 +100,16 @@ def _default_nexo_home() -> Path:
     return resolve_nexo_home(os.environ.get("NEXO_HOME", str(_user_home() / ".nexo")))
 
 
+def _read_json_file(path: Path) -> dict:
+    if not path.is_file():
+        return {}
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
 def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     explicit = (explicit or "").strip()
     if explicit:
@@ -106,6 +117,16 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
     env_name = os.environ.get("NEXO_NAME", "").strip()
     if env_name:
         return env_name
+    calibration = _read_json_file(nexo_home / "personal" / "brain" / "calibration.json")
+    user_payload = calibration.get("user")
+    if isinstance(user_payload, dict):
+        candidate = str(user_payload.get("assistant_name", "")).strip()
+        if candidate:
+            return candidate
+    for key in ("assistant_name", "identity", "operator_name"):
+        candidate = str(calibration.get(key, "")).strip()
+        if candidate:
+            return candidate
     version_file = nexo_home / "version.json"
     if version_file.is_file():
         try:
@@ -114,7 +135,7 @@ def _resolve_operator_name(nexo_home: Path, explicit: str = "") -> str:
                 return candidate
         except Exception:
             pass
-    return "NEXO"
+    return DEFAULT_ASSISTANT_NAME
 
 
 def _resolve_runtime_root(nexo_home: Path, runtime_root: str | os.PathLike[str] | None = None) -> Path:

package/src/cognitive/_core.py

@@ -11,11 +11,13 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Optional
 
+import paths
+
 NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-_data_dir = os.path.join(NEXO_HOME, "data")
-os.makedirs(_data_dir, exist_ok=True)
+_cognitive_dir = paths.cognitive_dir()
+_cognitive_dir.mkdir(parents=True, exist_ok=True)
 
-COGNITIVE_DB = os.path.join(_data_dir, "cognitive.db")
+COGNITIVE_DB = str(_cognitive_dir / "cognitive.db")
 EMBEDDING_DIM = 768
 LAMBDA_STM = 0.004126   # half-life = ln(2) / (7 * 24) ≈ 7 days
 LAMBDA_LTM = 0.000481  # half-life = ln(2) / (60 * 24) ≈ 60 days

package/src/core_prompts.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+"""Shared prompt catalog for productized NEXO core automations."""
+
+import os
+import re
+from functools import lru_cache
+from pathlib import Path
+
+_TOKEN_RE = re.compile(r"\[\[([a-zA-Z0-9_]+)\]\]")
+
+
+def _resolve_repo_root() -> Path:
+    candidate = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent))).expanduser().resolve()
+    if candidate.name == "src":
+        return candidate.parent
+    if (candidate / "templates").is_dir():
+        return candidate
+    if (candidate.parent / "templates").is_dir():
+        return candidate.parent
+    return Path(__file__).resolve().parents[1]
+
+
+PROMPTS_DIR = _resolve_repo_root() / "templates" / "core-prompts"
+
+
+@lru_cache(maxsize=None)
+def load_core_prompt_template(name: str) -> str:
+    path = PROMPTS_DIR / f"{name}.md"
+    if not path.is_file():
+        raise FileNotFoundError(f"Core prompt template not found: {path}")
+    return path.read_text(encoding="utf-8")
+
+
+def render_core_prompt(name: str, /, **values: object) -> str:
+    template = load_core_prompt_template(name)
+    required = {match.group(1) for match in _TOKEN_RE.finditer(template)}
+    missing = sorted(key for key in required if key not in values)
+    if missing:
+        raise KeyError(f"Missing values for core prompt '{name}': {', '.join(missing)}")
+
+    rendered = _TOKEN_RE.sub(lambda match: str(values[match.group(1)]), template)
+    return rendered.rstrip("\n")
+
+
+__all__ = [
+    "PROMPTS_DIR",
+    "load_core_prompt_template",
+    "render_core_prompt",
+]

package/src/cron_recovery.py

@@ -8,6 +8,7 @@ import plistlib
 import sqlite3
 import contextlib
 import hashlib
+import platform
 import socket
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -34,6 +35,68 @@ def _load_json(path: Path, default):
     return default
 
 
+def _normalize_platform_name(system: str | None = None) -> str:
+    value = str(system or os.environ.get("NEXO_PLATFORM") or platform.system()).strip().lower()
+    if value.startswith("darwin") or value.startswith("mac"):
+        return "darwin"
+    if value.startswith("linux"):
+        return "linux"
+    return value
+
+
+def _normalize_power_policy_name(value: str | None) -> str:
+    return str(value or "unset").strip().lower().replace("-", "_")
+
+
+def _cron_platform_enabled(cron: dict, *, system: str | None = None) -> bool:
+    allowed = cron.get("platforms")
+    if allowed is None:
+        allowed = cron.get("platform")
+    if not allowed:
+        return True
+    if isinstance(allowed, str):
+        values = [allowed]
+    elif isinstance(allowed, (list, tuple, set)):
+        values = list(allowed)
+    else:
+        return True
+    current = _normalize_platform_name(system)
+    normalized = {_normalize_platform_name(str(item)) for item in values if str(item).strip()}
+    return not normalized or current in normalized
+
+
+def is_cron_enabled(
+    cron: dict,
+    *,
+    optionals: dict[str, bool] | None = None,
+    schedule_data: dict | None = None,
+    system: str | None = None,
+) -> bool:
+    optionals = optionals or {}
+    schedule_data = schedule_data or {}
+
+    optional_key = cron.get("optional")
+    automation_default = bool(schedule_data.get("automation_enabled", True))
+    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:
+        return False
+
+    if not _cron_platform_enabled(cron, system=system):
+        return False
+
+    required_power_policy = cron.get("requires_power_policy")
+    if required_power_policy:
+        current_policy = _normalize_power_policy_name(schedule_data.get("power_policy"))
+        expected_policy = _normalize_power_policy_name(required_power_policy)
+        if current_policy != expected_policy:
+            return False
+
+    return True
+
+
 def _schedule_machine_id() -> str:
     schedule = _load_json(SCHEDULE_FILE, {})
     if isinstance(schedule, dict):
@@ -88,6 +151,10 @@ def load_enabled_crons() -> list[dict]:
         from automation_controls import apply_core_automation_overrides
     except Exception:
         apply_core_automation_overrides = None
+    try:
+        from product_mode import filter_blocked_crons
+    except Exception:
+        filter_blocked_crons = None
 
     manifest_candidates = [
         paths.crons_dir() / "manifest.json",
@@ -97,7 +164,9 @@ def load_enabled_crons() -> list[dict]:
     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
+    if not isinstance(schedule_data, dict):
+        schedule_data = {}
+    platform_name = _normalize_platform_name()
 
     for manifest_path in manifest_candidates:
         if not manifest_path.is_file():
@@ -109,14 +178,19 @@ def load_enabled_crons() -> list[dict]:
 
         enabled = []
         for cron in data.get("crons", []):
-            optional_key = cron.get("optional")
-            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:
+            if not is_cron_enabled(
+                cron,
+                optionals=optionals,
+                schedule_data=schedule_data,
+                system=platform_name,
+            ):
                 continue
             enabled.append(dict(cron))
+        if callable(filter_blocked_crons):
+            try:
+                enabled = filter_blocked_crons(enabled)
+            except Exception:
+                pass
         if callable(apply_core_automation_overrides):
             try:
                 return apply_core_automation_overrides(enabled)