nexo-brain 7.29.0 → 7.30.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.29.0",
+  "version": "7.30.1",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.29.0` is the current packaged-runtime line. Minor release over v7.28.0 - the morning briefing now has structured content preferences, Desktop-facing briefing presentation state, and per-account email signature support.
+Version `7.30.1` is the current packaged-runtime line. Patch release over v7.30.0 - morning briefings now behave more like a start-of-day assistant, explain news/weather as verified optional sources, and keep user type inference inside NEXO instead of asking the user to choose a role manually.
+
+Previously in `7.30.0`: minor release over v7.29.0 - morning briefing preferences now support weather/news, selectable weekdays, safer SMTP certificates, Opus 4.8 defaults, and an agent-facing preference catalog so NEXO can explain or change supported settings by chat.
+
+Previously in `7.29.0`: minor release over v7.28.0 - the morning briefing now has structured content preferences, Desktop-facing briefing presentation state, and per-account email signature support.
 
 Previously in `7.28.0`: minor release over v7.27.6 - the Brain memory architecture now links action authorship, reasons, operational state, entity profiles, failure prevention, semantic layers, and release-gated runtime memory benchmarks.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.29.0",
+  "version": "7.30.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/auto_update.py

@@ -2001,6 +2001,75 @@ def _relocate_resonance_tiers_contract(dest: Path = NEXO_HOME) -> list[str]:
     return actions
 
 
+def _refresh_resonance_tiers_model_defaults(dest: Path = NEXO_HOME) -> list[str]:
+    """Upgrade persisted resonance contracts that still use old NEXO defaults.
+
+    Existing users keep a public ``resonance_tiers.json`` contract in their
+    personal brain. Source defaults alone do not update that file, so known
+    Opus defaults must be migrated in place while custom models are left alone.
+    """
+    actions: list[str] = []
+    source_path = Path(__file__).resolve().parent / "resonance_tiers.json"
+    try:
+        source_payload = json.loads(source_path.read_text())
+    except Exception as exc:
+        return [f"resonance-default-refresh-warning:source:{exc.__class__.__name__}"]
+
+    target_paths = [
+        dest / "personal" / "brain" / "resonance_tiers.json",
+        dest / "brain" / "resonance_tiers.json",
+    ]
+    old_prefixes = ("claude-opus-4-6", "claude-opus-4-7")
+
+    for target_path in target_paths:
+        try:
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+            if target_path.is_file():
+                payload = json.loads(target_path.read_text())
+            else:
+                if target_path != target_paths[0]:
+                    continue
+                payload = json.loads(json.dumps(source_payload))
+        except Exception as exc:
+            actions.append(f"resonance-default-refresh-warning:read:{target_path.name}:{exc.__class__.__name__}")
+            continue
+
+        changed = False
+        tiers = payload.get("tiers") if isinstance(payload, dict) else {}
+        source_tiers = source_payload.get("tiers") if isinstance(source_payload, dict) else {}
+        if not isinstance(tiers, dict) or not isinstance(source_tiers, dict):
+            continue
+
+        for tier_name, tier_payload in tiers.items():
+            if not isinstance(tier_payload, dict):
+                continue
+            claude = tier_payload.get("claude_code")
+            source_claude = (source_tiers.get(tier_name) or {}).get("claude_code") if isinstance(source_tiers.get(tier_name), dict) else {}
+            if not isinstance(claude, dict) or not isinstance(source_claude, dict):
+                continue
+            model = str(claude.get("model") or "").strip()
+            tier_changed = False
+            if model and model.startswith(old_prefixes):
+                claude["model"] = str(source_claude.get("model") or "claude-opus-4-8")
+                tier_changed = True
+            if tier_changed and not str(claude.get("effort") or "").strip() and source_claude.get("effort"):
+                claude["effort"] = str(source_claude.get("effort"))
+            changed = changed or tier_changed
+
+        if "default_tier" not in payload and source_payload.get("default_tier"):
+            payload["default_tier"] = source_payload.get("default_tier")
+            changed = True
+
+        if changed or not target_path.is_file():
+            try:
+                target_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+                actions.append(f"resonance-default-refresh:{target_path.name}")
+            except Exception as exc:
+                actions.append(f"resonance-default-refresh-warning:write:{target_path.name}:{exc.__class__.__name__}")
+
+    return actions
+
+
 def _bootstrap_profile_from_calibration_meta(dest: Path = NEXO_HOME) -> list[str]:
     """Create ``brain/profile.json`` from ``calibration.json`` fields when the
     profile file does not exist yet.
@@ -5045,6 +5114,9 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
         reloc_actions = _relocate_resonance_tiers_contract(dest)
         for action in reloc_actions:
             actions.append(action)
+        refresh_actions = _refresh_resonance_tiers_model_defaults(dest)
+        for action in refresh_actions:
+            actions.append(action)
     except Exception as exc:
         actions.append(f"resonance-contract-relocate-warning:{exc.__class__.__name__}")
 

package/src/automation_controls.py

@@ -44,6 +44,58 @@ _CORE_AUTOMATION_SCHEDULES: dict[str, dict[str, Any]] = {
 }
 
 EXTRA_INSTRUCTIONS_METADATA_KEY = "operator_extra_instructions"
+_WEEKDAY_ORDER = (1, 2, 3, 4, 5, 6, 0)
+_WEEKDAY_LABELS = {
+    0: "Sun",
+    1: "Mon",
+    2: "Tue",
+    3: "Wed",
+    4: "Thu",
+    5: "Fri",
+    6: "Sat",
+}
+_WEEKDAY_ALIASES = {
+    "0": 0,
+    "7": 0,
+    "sun": 0,
+    "sunday": 0,
+    "domingo": 0,
+    "dom": 0,
+    "1": 1,
+    "mon": 1,
+    "monday": 1,
+    "lunes": 1,
+    "lun": 1,
+    "2": 2,
+    "tue": 2,
+    "tuesday": 2,
+    "martes": 2,
+    "mar": 2,
+    "3": 3,
+    "wed": 3,
+    "wednesday": 3,
+    "miercoles": 3,
+    "miércoles": 3,
+    "mie": 3,
+    "mié": 3,
+    "4": 4,
+    "thu": 4,
+    "thursday": 4,
+    "jueves": 4,
+    "jue": 4,
+    "5": 5,
+    "fri": 5,
+    "friday": 5,
+    "viernes": 5,
+    "vie": 5,
+    "6": 6,
+    "sat": 6,
+    "saturday": 6,
+    "sabado": 6,
+    "sábado": 6,
+    "sab": 6,
+    "sáb": 6,
+}
 
 
 _EMAIL_REQUIRED_SCRIPTS: dict[str, dict[str, Any]] = {
@@ -192,6 +244,98 @@ def get_core_manifest_cron(name: str) -> dict[str, Any]:
     return {}
 
 
+def _normalize_weekdays(value: Any) -> list[int] | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        raw = value.strip().lower()
+        if not raw or raw in {"all", "daily", "everyday", "cada dia", "cada día"}:
+            return []
+        parts = [part.strip() for part in raw.replace(";", ",").replace("|", ",").replace("+", ",").split(",")]
+    elif isinstance(value, (list, tuple, set)):
+        parts = list(value)
+    else:
+        return None
+
+    selected: set[int] = set()
+    invalid = False
+    for part in parts:
+        key = str(part).strip().lower()
+        if not key:
+            continue
+        if "-" in key:
+            left, right = [piece.strip() for piece in key.split("-", 1)]
+            start = _WEEKDAY_ALIASES.get(left)
+            end = _WEEKDAY_ALIASES.get(right)
+            if start is not None and end is not None:
+                ordered = list(_WEEKDAY_ORDER)
+                start_index = ordered.index(start)
+                end_index = ordered.index(end)
+                if start_index <= end_index:
+                    selected.update(ordered[start_index:end_index + 1])
+                else:
+                    selected.update(ordered[start_index:] + ordered[:end_index + 1])
+                continue
+            invalid = True
+            continue
+        if key in _WEEKDAY_ALIASES:
+            selected.add(_WEEKDAY_ALIASES[key])
+            continue
+        try:
+            day_number = int(key)
+            if 0 <= day_number <= 7:
+                selected.add(day_number % 7)
+                continue
+        except Exception:
+            pass
+        invalid = True
+    if invalid:
+        return None
+    if len(selected) >= 7:
+        return []
+    return [day for day in _WEEKDAY_ORDER if day in selected]
+
+
+def _schedule_weekdays(schedule: dict[str, Any]) -> list[int]:
+    if not isinstance(schedule, dict):
+        return []
+    normalized = _normalize_weekdays(schedule.get("weekdays"))
+    if normalized is not None:
+        return normalized
+    if "weekday" in schedule:
+        normalized = _normalize_weekdays([schedule.get("weekday")])
+        return normalized or []
+    return []
+
+
+def _apply_weekdays_to_schedule(schedule: dict[str, Any], weekdays: list[int] | None) -> dict[str, Any]:
+    next_schedule = dict(schedule)
+    next_schedule.pop("weekday", None)
+    if weekdays:
+        next_schedule["weekdays"] = weekdays
+    else:
+        next_schedule.pop("weekdays", None)
+    return next_schedule
+
+
+def _same_calendar_schedule(left: dict[str, Any], right: dict[str, Any]) -> bool:
+    def normalized(payload: dict[str, Any]) -> dict[str, Any]:
+        out = dict(payload or {})
+        weekdays = _schedule_weekdays(out)
+        out.pop("weekday", None)
+        out.pop("weekdays", None)
+        if weekdays:
+            out["weekdays"] = weekdays
+        return out
+
+    return normalized(left) == normalized(right)
+
+
+def _normalize_calendar_schedule(schedule: dict[str, Any]) -> dict[str, Any]:
+    normalized = dict(schedule or {})
+    return _apply_weekdays_to_schedule(normalized, _schedule_weekdays(normalized))
+
+
 def _format_interval_label(interval_seconds: int) -> str:
     interval = max(1, int(interval_seconds or 0))
     if interval % 3600 == 0:
@@ -210,12 +354,9 @@ def _format_calendar_label(schedule: dict[str, Any]) -> str:
     except Exception:
         return ""
     label = f"{hour:02d}:{minute:02d}"
-    if "weekday" in schedule:
-        try:
-            weekday = int(schedule.get("weekday", 0))
-        except Exception:
-            weekday = 0
-        label += f" weekday={weekday}"
+    weekdays = _schedule_weekdays(schedule)
+    if weekdays:
+        label += " " + ",".join(_WEEKDAY_LABELS.get(day, str(day)) for day in weekdays)
     else:
         label += " daily"
     return label
@@ -232,13 +373,15 @@ def _decorate_schedule_state(*, base_cron: dict[str, Any], effective_cron: dict[
         }
     schedule = effective_cron.get("schedule")
     if isinstance(schedule, dict) and schedule:
+        normalized_schedule = _normalize_calendar_schedule(schedule)
+        normalized_default = _normalize_calendar_schedule(dict(base_cron.get("schedule") or {}))
         return {
             "schedule_type": "calendar",
             "interval_seconds": 0,
             "default_interval_seconds": 0,
-            "schedule": dict(schedule),
-            "default_schedule": dict(base_cron.get("schedule") or {}),
-            "effective_schedule_label": _format_calendar_label(schedule),
+            "schedule": normalized_schedule,
+            "default_schedule": normalized_default,
+            "effective_schedule_label": _format_calendar_label(normalized_schedule),
             "schedule_source": source,
         }
     return {
@@ -354,6 +497,7 @@ def set_core_automation_schedule(
     *,
     interval_seconds: int | None = None,
     daily_at: str | None = None,
+    weekdays: Any = None,
     clear: bool = False,
 ) -> dict[str, Any]:
     clean_name = _normalize_name(name)
@@ -382,10 +526,15 @@ def set_core_automation_schedule(
             parsed_daily_at = _parse_daily_at(daily_at or "")
             if not parsed_daily_at:
                 return {"ok": False, "error": "daily_at must use HH:MM (24h) format"}
+            normalized_weekdays = _normalize_weekdays(weekdays)
+            if weekdays is not None and normalized_weekdays is None:
+                return {"ok": False, "error": "weekdays must be a comma-separated list like Mon-Fri or Tue,Sat"}
             default_schedule = dict(base_cron.get("schedule") or {})
             next_schedule = dict(default_schedule)
             next_schedule.update(parsed_daily_at)
-            next_override = {} if next_schedule == default_schedule else {"schedule": next_schedule}
+            if normalized_weekdays is not None:
+                next_schedule = _apply_weekdays_to_schedule(next_schedule, normalized_weekdays)
+            next_override = {} if _same_calendar_schedule(next_schedule, default_schedule) else {"schedule": next_schedule}
         else:
             try:
                 normalized_interval = int(interval_seconds or 0)
@@ -420,6 +569,8 @@ def set_core_automation_schedule(
         "schedule_type": str(state.get("schedule_type") or ""),
         "schedule_source": str(state.get("schedule_source") or ""),
         "effective_schedule_label": str(state.get("effective_schedule_label") or ""),
+        "schedule": state.get("schedule"),
+        "default_schedule": state.get("default_schedule"),
         "interval_seconds": int(state.get("interval_seconds", 0) or 0),
         "default_interval_seconds": int(state.get("default_interval_seconds", 0) or 0),
         "minimum_interval_seconds": int(state.get("minimum_interval_seconds", 0) or 0),
@@ -687,6 +838,8 @@ def get_script_runtime_contract(name: str) -> dict[str, Any]:
         "schedule_type": str(schedule_state.get("schedule_type") or ""),
         "schedule_source": str(schedule_state.get("schedule_source") or ""),
         "effective_schedule_label": str(schedule_state.get("effective_schedule_label") or ""),
+        "schedule": schedule_state.get("schedule"),
+        "default_schedule": schedule_state.get("default_schedule"),
         "interval_seconds": int(schedule_state.get("interval_seconds", 0) or 0),
         "default_interval_seconds": int(schedule_state.get("default_interval_seconds", 0) or 0),
         "minimum_interval_seconds": int(schedule_state.get("minimum_interval_seconds", 0) or 0),
@@ -737,6 +890,7 @@ def get_operator_profile() -> dict[str, Any]:
     language = "en"
     operator_email = ""
     operator_accounts: list[dict] = []
+    profile_payload: dict[str, Any] = {}
 
     try:
         from calibration_runtime import load_runtime_calibration
@@ -763,6 +917,13 @@ def get_operator_profile() -> dict[str, Any]:
                 or str(payload.get("lang") or "").strip()
                 or language
             )
+        profile_path = brain_dir() / "profile.json"
+        if profile_path.exists():
+            loaded_profile = json.loads(profile_path.read_text())
+            if isinstance(loaded_profile, dict):
+                profile_payload = loaded_profile
+                operator_name = str(loaded_profile.get("name") or operator_name).strip() or operator_name
+                language = str(loaded_profile.get("language") or language).strip() or language
     except Exception:
         pass
 
@@ -797,6 +958,15 @@ def get_operator_profile() -> dict[str, Any]:
         "operator_email": operator_email,
         "operator_aliases": aliases,
         "operator_accounts": operator_accounts,
+        "current_residence": profile_payload.get("current_residence"),
+        "timezone": profile_payload.get("timezone"),
+        "location": profile_payload.get("location"),
+        "coordinates": profile_payload.get("coordinates"),
+        "latitude": profile_payload.get("latitude"),
+        "longitude": profile_payload.get("longitude"),
+        "role": profile_payload.get("role"),
+        "technical_level": profile_payload.get("technical_level"),
+        "news_rss_url": profile_payload.get("news_rss_url"),
     }
 
 

package/src/automation_preferences.py

@@ -22,29 +22,75 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
             "id": "content",
             "label": "Content",
             "items": [
-                {"id": "priorities", "type": "boolean", "label": "Priorities", "default": True},
-                {"id": "agenda", "type": "boolean", "label": "Agenda", "default": True},
-                {"id": "reminders", "type": "boolean", "label": "Reminders and tasks", "default": True},
-                {"id": "followups", "type": "boolean", "label": "Follow-ups", "default": True},
-                {"id": "decisions", "type": "boolean", "label": "Recent decisions", "default": True},
-                {"id": "email_activity", "type": "boolean", "label": "Recent sent email", "default": True},
-                {"id": "blockers", "type": "boolean", "label": "Blockers and risks", "default": True},
-                {"id": "internal_refs", "type": "boolean", "label": "Internal references", "default": False},
+                {
+                    "id": "priorities",
+                    "type": "boolean",
+                    "label": "Priorities",
+                    "default": True,
+                    "help": "The most important things NEXO thinks you should look at first.",
+                },
+                {
+                    "id": "agenda",
+                    "type": "boolean",
+                    "label": "Agenda",
+                    "default": True,
+                    "help": "Calendar-like items, dated work and events that affect today.",
+                },
+                {
+                    "id": "reminders",
+                    "type": "boolean",
+                    "label": "Reminders and tasks",
+                    "default": True,
+                    "help": "Pending reminders and tasks saved in NEXO.",
+                },
+                {
+                    "id": "followups",
+                    "type": "boolean",
+                    "label": "Follow-ups",
+                    "default": True,
+                    "help": "Open work that NEXO is tracking until it is resolved or clearly blocked.",
+                },
+                {
+                    "id": "decisions",
+                    "type": "boolean",
+                    "label": "Recent decisions",
+                    "default": True,
+                    "help": "Important decisions recorded recently so they are not forgotten.",
+                },
+                {
+                    "id": "email_activity",
+                    "type": "boolean",
+                    "label": "Recent sent email",
+                    "default": True,
+                    "help": "Emails NEXO sent recently, useful to know what moved while you were away.",
+                },
+                {
+                    "id": "blockers",
+                    "type": "boolean",
+                    "label": "Blockers and risks",
+                    "default": True,
+                    "help": "Things that may stop progress, need your decision or could become a problem.",
+                },
+                {
+                    "id": "internal_refs",
+                    "type": "boolean",
+                    "label": "Internal references",
+                    "default": False,
+                    "help": "Technical file names, IDs or internal references. Keep this off for a cleaner human summary.",
+                },
                 {
                     "id": "news",
                     "type": "boolean",
                     "label": "News",
                     "default": False,
-                    "disabled": True,
-                    "disabled_reason": "No verified news source is connected yet.",
+                    "help": "A short set of current public headlines from the configured news feed, included only when the source can be verified.",
                 },
                 {
                     "id": "weather",
                     "type": "boolean",
                     "label": "Weather",
-                    "default": False,
-                    "disabled": True,
-                    "disabled_reason": "No verified weather source is connected yet.",
+                    "default": True,
+                    "help": "Today's weather from the location saved in Desktop or your residence in the profile, included only when the forecast can be verified.",
                 },
             ],
         },
@@ -58,6 +104,7 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "label": "Length",
                     "default": "normal",
                     "options": ["short", "normal", "detailed"],
+                    "help": "How much detail the briefing should include.",
                 },
                 {
                     "id": "tone",
@@ -65,6 +112,7 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "label": "Tone",
                     "default": "direct",
                     "options": ["direct", "warm", "executive", "personal"],
+                    "help": "How NEXO should write the summary.",
                 },
                 {
                     "id": "format",
@@ -72,6 +120,7 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "label": "Format",
                     "default": "sections",
                     "options": ["sections", "bullets", "narrative"],
+                    "help": "How the briefing is organized visually.",
                 },
             ],
         },
@@ -85,13 +134,7 @@ MORNING_AGENT_SCHEMA: dict[str, Any] = {
                     "label": "Quiet days",
                     "default": "summary_if_anything_important",
                     "options": ["always_send", "summary_if_anything_important", "skip_if_empty"],
-                },
-                {
-                    "id": "audience",
-                    "type": "choice",
-                    "label": "User type",
-                    "default": "operator",
-                    "options": ["operator", "founder", "student", "sales", "technical", "personal"],
+                    "help": "What NEXO should do on days with little or no important activity.",
                 },
             ],
         },
@@ -279,6 +322,7 @@ def search_automation_preference_schema(name: str, query: str) -> list[dict[str,
                 str(item.get("id") or ""),
                 str(item.get("label") or ""),
                 str(item.get("disabled_reason") or ""),
+                str(item.get("help") or ""),
                 str(group.get("label") or ""),
             ])
             if clean_query in _fold_text(text):
@@ -304,8 +348,12 @@ def format_automation_preferences_prompt_block(name_or_path: str) -> str:
     return (
         "\n== STRUCTURED CONTENT PREFERENCES FOR THIS AUTOMATION ==\n"
         f"{compact}\n"
+        "Morning briefing intent: act like a professional personal assistant preparing the operator for the day. "
+        "Do not merely list available records; filter, rank, and explain what deserves attention first.\n"
+        "Adapt the emphasis from the operator profile, role, recent activity, and context. "
+        "Do not ask the user to choose a user type manually and do not assume a profession unless the context supports it.\n"
         "Use these preferences to decide what to include, omit, and emphasize. "
-        "Disabled/unavailable data sources must not be invented.\n"
+        "Disabled/unavailable data sources must not be invented; news and weather require verified collected data.\n"
     )
 
 

package/src/cli.py

@@ -1037,11 +1037,19 @@ def _automations_set_schedule(args):
         interval_seconds = int(args.every_seconds)
     elif getattr(args, "daily_at", None):
         daily_at = str(args.daily_at).strip()
+    if getattr(args, "weekdays", None) and not daily_at:
+        result = {"ok": False, "error": "--weekdays can only be used with --daily-at"}
+        if args.json:
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 1
+        print(result["error"], file=sys.stderr)
+        return 1
 
     result = set_automation_schedule(
         args.name,
         interval_seconds=interval_seconds,
         daily_at=daily_at,
+        weekdays=getattr(args, "weekdays", None),
         clear=bool(getattr(args, "reset", False)),
     )
     if args.json:
@@ -2612,6 +2620,28 @@ def _preferences(args):
         _load_user_default_resonance,
     )
 
+    action = str(getattr(args, "preferences_action", "") or "").strip().lower()
+    if action in {"catalog", "get", "set", "explain"}:
+        from preference_catalog import build_preference_catalog, explain_preference, set_preference
+
+        if action == "catalog":
+            payload = build_preference_catalog(
+                include_values=bool(getattr(args, "include_values", False)),
+                query=str(getattr(args, "query", "") or "").strip() or None,
+            )
+        elif action in {"get", "explain"}:
+            pref_id = str(getattr(args, "preferences_id", "") or "").strip()
+            payload = explain_preference(pref_id)
+        else:
+            pref_id = str(getattr(args, "preferences_id", "") or "").strip()
+            value = getattr(args, "preferences_value", None)
+            payload = set_preference(pref_id, value, dry_run=bool(getattr(args, "dry_run", False)))
+        if getattr(args, "json", False):
+            print(json.dumps(payload, indent=2, ensure_ascii=False))
+        else:
+            print(json.dumps(payload, ensure_ascii=False))
+        return 0 if payload.get("ok", True) else 1
+
     prefs = load_client_preferences()
     if not isinstance(prefs, dict):
         prefs = {}
@@ -4150,6 +4180,7 @@ def main():
     automations_schedule_group.add_argument("--every-seconds", type=int, help="Run the automation every N seconds")
     automations_schedule_group.add_argument("--daily-at", type=str, help="Run the automation every day at HH:MM (24h)")
     automations_schedule_group.add_argument("--reset", action="store_true", help="Restore the shipped default cadence")
+    automations_schedule_p.add_argument("--weekdays", default=None, help="Optional calendar days, e.g. Mon-Fri or Tue,Sat")
     automations_schedule_p.add_argument("--json", action="store_true", help="JSON output")
 
     automations_schema_p = automations_sub.add_parser(
@@ -4281,6 +4312,12 @@ def main():
         "preferences",
         help="Read or change NEXO user preferences (resonance, default client, ...)",
     )
+    preferences_parser.add_argument("preferences_action", nargs="?", choices=["catalog", "get", "set", "explain"], help="Catalog operation")
+    preferences_parser.add_argument("preferences_id", nargs="?", help="Preference id or alias")
+    preferences_parser.add_argument("preferences_value", nargs="?", help="Value for `preferences set`")
+    preferences_parser.add_argument("--query", default="", help="Filter catalog entries")
+    preferences_parser.add_argument("--include-values", action="store_true", help="Include current values in catalog output")
+    preferences_parser.add_argument("--dry-run", action="store_true", help="Preview a preference change")
     preferences_parser.add_argument(
         "--resonance",
         choices=["maximo", "alto", "medio", "bajo"],