nexo-brain 7.29.0 → 7.30.1

package/src/cron_recovery.py

@@ -124,7 +124,7 @@ def resolve_declared_schedule(cron: dict) -> dict:
     resolved = dict(schedule)
     strategy = str(cron.get("schedule_strategy") or resolved.pop("strategy", "")).strip().lower()
     if strategy != "machine_weekly_spread":
-        return resolved
+        return _normalize_declared_weekdays(resolved)
 
     if not {"hour", "minute", "weekday"} <= resolved.keys():
         return resolved
@@ -146,6 +146,41 @@ def resolve_declared_schedule(cron: dict) -> dict:
     }
 
 
+def _normalize_weekdays(value) -> list[int] | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        parts = [part.strip() for part in value.replace("+", ",").split(",")]
+    elif isinstance(value, (list, tuple, set)):
+        parts = list(value)
+    else:
+        return None
+    selected: set[int] = set()
+    for part in parts:
+        try:
+            selected.add(int(part) % 7)
+        except Exception:
+            continue
+    if len(selected) >= 7:
+        return []
+    order = (1, 2, 3, 4, 5, 6, 0)
+    return [day for day in order if day in selected]
+
+
+def _normalize_declared_weekdays(schedule: dict) -> dict:
+    result = dict(schedule or {})
+    weekdays = _normalize_weekdays(result.get("weekdays"))
+    if weekdays is None and "weekday" in result:
+        weekdays = _normalize_weekdays([result.get("weekday")])
+    if weekdays:
+        result.pop("weekday", None)
+        result["weekdays"] = weekdays
+    elif weekdays == []:
+        result.pop("weekday", None)
+        result.pop("weekdays", None)
+    return result
+
+
 def load_enabled_crons() -> list[dict]:
     try:
         from automation_controls import apply_core_automation_overrides
@@ -276,7 +311,7 @@ def default_max_catchup_age(cron: dict) -> int:
         interval = int(cron["interval_seconds"])
         return max(interval * 4, interval + 900)
     schedule = cron.get("schedule") or {}
-    if "weekday" in schedule:
+    if "weekday" in schedule or "weekdays" in schedule:
         return 14 * 86400
     if "hour" in schedule and "minute" in schedule:
         return 48 * 3600
@@ -478,14 +513,34 @@ def legacy_state_runs(*, state_file: Path = STATE_FILE) -> dict[str, datetime]:
     return parsed
 
 
-def last_scheduled_time(calendar: dict, now: datetime | None = None) -> datetime:
+def last_scheduled_time(calendar: dict | list, now: datetime | None = None) -> datetime:
     now = now or datetime.now().astimezone(_local_timezone())
     if now.tzinfo is None:
         now = now.replace(tzinfo=_local_timezone())
 
+    if isinstance(calendar, list):
+        candidates = [
+            last_scheduled_time(item, now)
+            for item in calendar
+            if isinstance(item, dict)
+        ]
+        if candidates:
+            return max(candidates)
+        return now
+
     hour = int(calendar.get("hour", calendar.get("Hour", 0)))
     minute = int(calendar.get("minute", calendar.get("Minute", 0)))
     weekday = calendar.get("weekday", calendar.get("Weekday"))
+    weekdays = calendar.get("weekdays") or calendar.get("Weekdays")
+    normalized_weekdays = _normalize_weekdays(weekdays)
+    if normalized_weekdays:
+        base_calendar = dict(calendar)
+        base_calendar.pop("weekdays", None)
+        base_calendar.pop("Weekdays", None)
+        return max(
+            last_scheduled_time({**base_calendar, "weekday": day}, now)
+            for day in normalized_weekdays
+        )
 
     today_at = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
     if weekday is not None:

package/src/crons/sync.py

@@ -419,6 +419,43 @@ def _copy_into_runtime(src: Path) -> Path:
     return dest
 
 
+def _calendar_weekdays(schedule: dict) -> list[int]:
+    raw = schedule.get("weekdays") or schedule.get("Weekdays")
+    if raw is None and "weekday" in schedule:
+        raw = [schedule.get("weekday")]
+    if raw is None and "Weekday" in schedule:
+        raw = [schedule.get("Weekday")]
+    if isinstance(raw, str):
+        parts = [part.strip() for part in raw.replace("+", ",").split(",")]
+    elif isinstance(raw, (list, tuple, set)):
+        parts = list(raw)
+    else:
+        return []
+    selected: set[int] = set()
+    for part in parts:
+        try:
+            selected.add(int(part) % 7)
+        except Exception:
+            continue
+    if len(selected) >= 7:
+        return []
+    return [day for day in (1, 2, 3, 4, 5, 6, 0) if day in selected]
+
+
+def _launchd_calendar_intervals(schedule: dict) -> dict | list[dict]:
+    base = {}
+    if "hour" in schedule:
+        base["Hour"] = schedule["hour"]
+    if "minute" in schedule:
+        base["Minute"] = schedule["minute"]
+    weekdays = _calendar_weekdays(schedule)
+    if weekdays:
+        if len(weekdays) == 1:
+            return {**base, "Weekday": weekdays[0]}
+        return [{**base, "Weekday": day} for day in weekdays]
+    return base
+
+
 def build_plist(cron: dict) -> dict:
     """Build a macOS LaunchAgent plist dict from a manifest entry."""
     cron_id = cron["id"]
@@ -480,15 +517,8 @@ def build_plist(cron: dict) -> dict:
     if "interval_seconds" in cron and not cron.get("keep_alive"):
         plist["StartInterval"] = cron["interval_seconds"]
     elif "schedule" in cron and not cron.get("keep_alive"):
-        cal = {}
         s = resolve_declared_schedule(cron)
-        if "hour" in s:
-            cal["Hour"] = s["hour"]
-        if "minute" in s:
-            cal["Minute"] = s["minute"]
-        if "weekday" in s:
-            cal["Weekday"] = s["weekday"]
-        plist["StartCalendarInterval"] = cal
+        plist["StartCalendarInterval"] = _launchd_calendar_intervals(s)
 
     return plist
 
@@ -513,9 +543,9 @@ def _cron_schedule(cron: dict) -> str | None:
         s = resolve_declared_schedule(cron)
         hour, minute = int(s.get("hour", 0)), int(s.get("minute", 0))
         weekday = "*"
-        if "weekday" in s:
-            raw_weekday = int(s["weekday"])
-            weekday = "0" if raw_weekday == 7 else str(raw_weekday)
+        weekdays = _calendar_weekdays(s)
+        if weekdays:
+            weekday = ",".join("0" if int(day) == 7 else str(int(day) % 7) for day in weekdays)
         return f"{minute} {hour} * * {weekday}"
     return None
 
@@ -916,10 +946,13 @@ StandardError=append:{stderr_log}
         elif "schedule" in cron:
             s = resolve_declared_schedule(cron)
             h, m = s.get("hour", 0), s.get("minute", 0)
-            if "weekday" in s:
-                # Manifest weekday uses launchd convention: 0=Sunday … 6=Saturday (7=Sunday alias)
+            weekdays = _calendar_weekdays(s)
+            if weekdays:
                 days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
-                timer_spec = f"OnCalendar={days[s['weekday']]} *-*-* {h:02d}:{m:02d}:00"
+                timer_spec = "\n".join(
+                    f"OnCalendar={days[int(day) % 7]} *-*-* {h:02d}:{m:02d}:00"
+                    for day in weekdays
+                )
             else:
                 timer_spec = f"OnCalendar=*-*-* {h:02d}:{m:02d}:00"
         else:

package/src/model_defaults.json

@@ -1,11 +1,11 @@
 {
   "schema_version": 1,
   "claude_code": {
-    "model": "claude-opus-4-7[1m]",
+    "model": "claude-opus-4-8",
     "reasoning_effort": "max",
-    "display_name": "Opus 4.7 with 1M context",
-    "recommendation_version": 2,
-    "previous_defaults": ["claude-opus-4-6[1m]"]
+    "display_name": "Opus 4.8 with max reasoning",
+    "recommendation_version": 3,
+    "previous_defaults": ["claude-opus-4-7[1m]", "claude-opus-4-7", "claude-opus-4-6[1m]"]
   },
   "codex": {
     "model": "gpt-5.5",

package/src/model_defaults.py

@@ -20,11 +20,11 @@ from typing import Any
 _FALLBACK: dict[str, Any] = {
     "schema_version": 1,
     "claude_code": {
-        "model": "claude-opus-4-7[1m]",
+        "model": "claude-opus-4-8",
         "reasoning_effort": "max",
-        "display_name": "Opus 4.7 with 1M context",
-        "recommendation_version": 2,
-        "previous_defaults": ["claude-opus-4-6[1m]"],
+        "display_name": "Opus 4.8 with max reasoning",
+        "recommendation_version": 3,
+        "previous_defaults": ["claude-opus-4-7[1m]", "claude-opus-4-7", "claude-opus-4-6[1m]"],
     },
     "codex": {
         "model": "gpt-5.5",
@@ -99,14 +99,14 @@ def looks_like_claude_model(model: str) -> bool:
     return str(model or "").strip().lower().startswith(_CLAUDE_MODEL_PREFIXES)
 
 
-_OPUS_46_PREFIX = "claude-opus-4-6"
+_CLAUDE_DEFAULT_PREFIXES = ("claude-opus-4-6", "claude-opus-4-7")
 
 
 def heal_runtime_profiles(profiles: dict) -> tuple[dict, list[str]]:
     """Detect and repair invalid models in client_runtime_profiles. Returns
     (healed_profiles_dict, list_of_heal_messages). Handles two cases:
     1. Claude-family model in the codex profile (historical bug).
-    2. Opus 4.6 → 4.7 auto-migration for claude_code users on a NEXO default."""
+    2. Opus default auto-migration for claude_code users on a NEXO default."""
     if not isinstance(profiles, dict):
         return profiles, []
     healed = dict(profiles)
@@ -127,14 +127,13 @@ def heal_runtime_profiles(profiles: dict) -> tuple[dict, list[str]]:
                 f"(Claude models are invalid for Codex)."
             )
 
-    # --- Opus 4.6 → 4.7 auto-migration for claude_code ---
+    # --- Opus default auto-migration for claude_code ---
     cc_profile = healed.get("claude_code") if isinstance(healed.get("claude_code"), dict) else None
     if cc_profile is not None:
         cc_model = str(cc_profile.get("model") or "").strip()
-        if cc_model.startswith(_OPUS_46_PREFIX):
+        if any(cc_model.startswith(prefix) for prefix in _CLAUDE_DEFAULT_PREFIXES):
             default = client_default("claude_code")
-            suffix = cc_model[len(_OPUS_46_PREFIX):]
-            new_model = f"claude-opus-4-7{suffix}"
+            new_model = default["model"]
             old_effort = str(cc_profile.get("reasoning_effort") or "").strip()
             new_effort = default["reasoning_effort"]
             healed["claude_code"] = dict(cc_profile)

package/src/plugins/desktop_preferences.py

@@ -0,0 +1,63 @@
+"""Agent-facing catalog and mutation tools for NEXO Desktop preferences."""
+
+from __future__ import annotations
+
+import json
+
+
+def handle_desktop_preferences_catalog(query: str = "", include_values: bool = True, locale: str = "es") -> str:
+    from preference_catalog import build_preference_catalog
+
+    return json.dumps(
+        build_preference_catalog(
+            include_values=bool(include_values),
+            query=str(query or "").strip() or None,
+            locale=str(locale or "es"),
+        ),
+        ensure_ascii=False,
+    )
+
+
+def handle_desktop_preference_get(id: str) -> str:
+    from preference_catalog import explain_preference
+
+    return json.dumps(explain_preference(id), ensure_ascii=False)
+
+
+def handle_desktop_preference_explain(id: str) -> str:
+    from preference_catalog import explain_preference
+
+    return json.dumps(explain_preference(id), ensure_ascii=False)
+
+
+def handle_desktop_preference_set(id: str, value: str, dry_run: bool = False) -> str:
+    from preference_catalog import set_preference
+
+    return json.dumps(
+        set_preference(id, value, dry_run=bool(dry_run)),
+        ensure_ascii=False,
+    )
+
+
+TOOLS = [
+    (
+        handle_desktop_preferences_catalog,
+        "nexo_desktop_preferences_catalog",
+        "List the settings and automation preferences NEXO can explain or change for the operator.",
+    ),
+    (
+        handle_desktop_preference_get,
+        "nexo_desktop_preference_get",
+        "Read one preference by id or alias, including its current value when available.",
+    ),
+    (
+        handle_desktop_preference_explain,
+        "nexo_desktop_preference_explain",
+        "Explain what one Desktop/Brain preference means and where it is stored.",
+    ),
+    (
+        handle_desktop_preference_set,
+        "nexo_desktop_preference_set",
+        "Change one supported preference by id or alias. Use dry_run=true to preview.",
+    ),
+]

package/src/plugins/personal_scripts.py

@@ -253,6 +253,7 @@ def handle_automation_schedule(
     name: str,
     every_seconds: int = 0,
     daily_at: str = "",
+    weekdays: str = "",
     clear: bool = False,
 ) -> str:
     init_db()
@@ -262,6 +263,7 @@ def handle_automation_schedule(
             name,
             interval_seconds=interval_seconds,
             daily_at=str(daily_at or "").strip() or None,
+            weekdays=str(weekdays or "").strip() or None,
             clear=bool(clear),
         ),
         ensure_ascii=False,

package/src/plugins/update.py

@@ -1829,9 +1829,13 @@ def handle_update(
             from client_sync import sync_all_clients
             from client_preferences import normalize_client_preferences
             from model_defaults import heal_runtime_profiles
+            from auto_update import _refresh_resonance_tiers_model_defaults
 
             schedule_path = paths.config_dir() / "schedule.json"
             schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
+            for action in _refresh_resonance_tiers_model_defaults(NEXO_HOME):
+                _emit_progress(progress_fn, action)
+                steps_done.append("resonance-default-refresh")
             # Heal Claude-family models written into Codex profile by earlier
             # buggy versions.  Must run BEFORE normalize so healed values
             # propagate into the saved preferences.