nexo-brain 7.28.0 → 7.30.0

package/src/cli_email.py

@@ -222,6 +222,7 @@ def _account_to_public_dict(account: dict) -> dict:
     if not isinstance(metadata, dict):
         metadata = {}
     legacy_migrated = bool(metadata.get("migrated_from_legacy_email_config"))
+    signature = str(metadata.get("signature") or "").strip()
     return {
         "id": account.get("id"),
         "label": account.get("label"),
@@ -244,6 +245,8 @@ def _account_to_public_dict(account: dict) -> dict:
         "is_default": bool(account.get("is_default")),
         "has_credential": bool(account.get("credential_service")
                                and account.get("credential_key")),
+        "signature_configured": bool(signature),
+        "signature_preview": " ".join(signature.split())[:120],
     }
 
 
@@ -626,6 +629,82 @@ def cmd_email_set_enabled(args) -> int:
     return 0
 
 
+def cmd_email_signature(args) -> int:
+    json_mode = bool(getattr(args, "json", False))
+    account_id, label = _selector_from_args(args)
+    if account_id is None and not label:
+        msg = _selector_usage("signature")
+        if json_mode:
+            _emit_json({"ok": False, "message": msg})
+        else:
+            print(msg)
+        return 1
+
+    from db import init_db
+    from db._email_accounts import add_email_account, get_email_account, get_email_account_by_id
+
+    init_db()
+    acc = get_email_account_by_id(account_id) if account_id is not None else get_email_account(label)
+    if not acc:
+        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
+
+    metadata = dict(acc.get("metadata") or {})
+    wants_set = any([
+        getattr(args, "text", None) is not None,
+        bool(getattr(args, "stdin", False)),
+        bool(getattr(args, "clear", False)),
+    ])
+    if wants_set:
+        if getattr(args, "clear", False):
+            metadata.pop("signature", None)
+        elif getattr(args, "stdin", False):
+            metadata["signature"] = sys.stdin.read().strip()
+        else:
+            metadata["signature"] = str(getattr(args, "text", "") or "").strip()
+        acc = add_email_account(
+            label=acc.get("label", ""),
+            email=acc.get("email", ""),
+            imap_host=acc.get("imap_host", ""),
+            imap_port=int(acc.get("imap_port") or 993),
+            smtp_host=acc.get("smtp_host", ""),
+            smtp_port=int(acc.get("smtp_port") or 465),
+            credential_service=acc.get("credential_service", ""),
+            credential_key=acc.get("credential_key", ""),
+            operator_email=acc.get("operator_email", ""),
+            trusted_domains=list(acc.get("trusted_domains") or []),
+            role=acc.get("role", "both"),
+            enabled=bool(acc.get("enabled", True)),
+            metadata=metadata,
+            account_type=acc.get("account_type", "agent"),
+            description=acc.get("description", ""),
+            can_read=bool(acc.get("can_read")),
+            can_send=bool(acc.get("can_send")),
+            is_default=bool(acc.get("is_default")),
+        )
+
+    signature = str((acc.get("metadata") or {}).get("signature") or "").strip()
+    payload = {
+        "ok": True,
+        "account": _account_to_public_dict(acc),
+        "signature": signature,
+        "cleared": wants_set and not bool(signature),
+    }
+    if json_mode:
+        _emit_json(payload)
+    else:
+        if wants_set:
+            print("Signature cleared." if not signature else "Signature saved.")
+        else:
+            print(signature or "(no signature configured)")
+    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="Manage NEXO email accounts")
@@ -704,6 +783,21 @@ def register_email_parser(subparsers) -> None:
     s.add_argument("--json", dest="json", action="store_true")
     s.set_defaults(func=cmd_email_set_enabled, enabled=False)
 
+    s = sub.add_parser("signature", help="Read or edit the signature for an account")
+    s.add_argument("label_pos", nargs="?", default=None,
+                   help="Account label (legacy positional)")
+    s.add_argument("--label", dest="label", default=None)
+    s.add_argument("--id", dest="account_id", type=int, default=None)
+    sig_group = s.add_mutually_exclusive_group()
+    sig_group.add_argument("--text", dest="text", default=None,
+                           help="Signature text to save")
+    sig_group.add_argument("--stdin", dest="stdin", action="store_true",
+                           help="Read signature text from stdin")
+    sig_group.add_argument("--clear", dest="clear", action="store_true",
+                           help="Clear the saved signature")
+    s.add_argument("--json", dest="json", action="store_true")
+    s.set_defaults(func=cmd_email_signature)
+
 
 __all__ = [
     "cmd_email_setup",
@@ -712,5 +806,6 @@ __all__ = [
     "cmd_email_test",
     "cmd_email_remove",
     "cmd_email_set_enabled",
+    "cmd_email_signature",
     "register_email_parser",
 ]

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/db/_schema.py

@@ -2758,6 +2758,23 @@ def _m76_semantic_layers(conn):
     _migrate_add_index(conn, "idx_semantic_layer_sources_kind", "semantic_layer_source_refs", "source_kind, validation_status")
 
 
+def _m77_morning_briefing_presentation(conn):
+    """Persist sanitized briefing bodies and Desktop read-state."""
+    _m58_morning_briefing_runs(conn)
+    _migrate_add_column(conn, "morning_briefing_runs", "body_text", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "body_html", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "artifact_json", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_shown_at", "TEXT DEFAULT NULL")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_opened_at", "TEXT DEFAULT NULL")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_dismissed_at", "TEXT DEFAULT NULL")
+    _migrate_add_index(
+        conn,
+        "idx_morning_briefing_runs_desktop",
+        "morning_briefing_runs",
+        "status, desktop_shown_at, finished_at",
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2835,6 +2852,7 @@ MIGRATIONS = [
     (74, "entity_live_profiles", _m74_entity_live_profiles),
     (75, "failure_prevention_ledger", _m75_failure_prevention_ledger),
     (76, "semantic_layers", _m76_semantic_layers),
+    (77, "morning_briefing_presentation", _m77_morning_briefing_presentation),
 ]
 
 

package/src/email_presentation.py

@@ -0,0 +1,243 @@
+"""Shared email presentation helpers for operator-facing automations.
+
+Agents may produce HTML, but SMTP, artifacts, and Desktop must only consume
+normalized/sanitized output from this module.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from typing import Any
+from urllib.parse import urlparse
+
+
+ALLOWED_TAGS = {
+    "a", "b", "blockquote", "br", "code", "div", "em", "h1", "h2", "h3",
+    "hr", "i", "li", "ol", "p", "pre", "span", "strong", "table", "tbody",
+    "td", "th", "thead", "tr", "u", "ul",
+}
+VOID_TAGS = {"br", "hr"}
+ALLOWED_ATTRS = {
+    "a": {"href", "title"},
+    "td": {"colspan", "rowspan"},
+    "th": {"colspan", "rowspan"},
+}
+SAFE_URL_SCHEMES = {"http", "https", "mailto"}
+
+
+@dataclass(frozen=True)
+class EmailPresentation:
+    subject: str
+    body_text: str
+    body_html: str
+    input_format: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "subject": self.subject,
+            "body_text": self.body_text,
+            "body_html": self.body_html,
+            "input_format": self.input_format,
+        }
+
+
+class _SafeHtmlParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        clean_tag = tag.lower()
+        if clean_tag in {"script", "style", "iframe", "object", "embed", "svg", "math"}:
+            self._skip_depth += 1
+            return
+        if self._skip_depth or clean_tag not in ALLOWED_TAGS:
+            return
+        attr_bits: list[str] = []
+        allowed = ALLOWED_ATTRS.get(clean_tag, set())
+        for raw_name, raw_value in attrs:
+            name = str(raw_name or "").lower().strip()
+            if not name or name.startswith("on") or name not in allowed:
+                continue
+            value = str(raw_value or "").strip()
+            if name == "href" and not _safe_href(value):
+                continue
+            if name in {"colspan", "rowspan"}:
+                value = str(max(1, min(12, _safe_int(value, 1))))
+            attr_bits.append(f'{name}="{html.escape(value, quote=True)}"')
+        suffix = (" " + " ".join(attr_bits)) if attr_bits else ""
+        self.parts.append(f"<{clean_tag}{suffix}>")
+
+    def handle_endtag(self, tag: str) -> None:
+        clean_tag = tag.lower()
+        if clean_tag in {"script", "style", "iframe", "object", "embed", "svg", "math"}:
+            if self._skip_depth:
+                self._skip_depth -= 1
+            return
+        if self._skip_depth or clean_tag not in ALLOWED_TAGS or clean_tag in VOID_TAGS:
+            return
+        self.parts.append(f"</{clean_tag}>")
+
+    def handle_data(self, data: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(html.escape(data, quote=False))
+
+    def handle_entityref(self, name: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(f"&{name};")
+
+    def handle_charref(self, name: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(f"&#{name};")
+
+
+def _safe_int(value: Any, fallback: int) -> int:
+    try:
+        return int(value)
+    except Exception:
+        return fallback
+
+
+def _safe_href(value: str) -> bool:
+    parsed = urlparse(value)
+    if parsed.scheme and parsed.scheme.lower() not in SAFE_URL_SCHEMES:
+        return False
+    if not parsed.scheme and value.strip().lower().startswith("javascript:"):
+        return False
+    return True
+
+
+def sanitize_html_fragment(raw_html: str) -> str:
+    parser = _SafeHtmlParser()
+    try:
+        parser.feed(str(raw_html or ""))
+        parser.close()
+    except Exception:
+        return ""
+    cleaned = "".join(parser.parts)
+    cleaned = re.sub(r"\s+javascript\s*:", "", cleaned, flags=re.I)
+    return cleaned.strip()
+
+
+def text_to_html_fragment(text: str) -> str:
+    paragraphs = re.split(r"\n{2,}", str(text or "").strip())
+    rendered: list[str] = []
+    for paragraph in paragraphs:
+        clean = html.escape(paragraph.strip(), quote=False)
+        if not clean:
+            continue
+        rendered.append(f"<p>{clean.replace(chr(10), '<br>')}</p>")
+    return "".join(rendered) or "<p></p>"
+
+
+def html_to_text(raw_html: str) -> str:
+    text = re.sub(r"(?is)<(script|style|iframe|object|embed|svg|math).*?</\1>", " ", str(raw_html or ""))
+    text = re.sub(r"(?i)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?i)</(p|div|li|h1|h2|h3|tr)>", "\n", text)
+    text = re.sub(r"<[^>]+>", " ", text)
+    text = html.unescape(text)
+    lines = [" ".join(line.split()) for line in text.splitlines()]
+    return "\n".join(line for line in lines if line).strip()
+
+
+def compose_html_document(fragment: str) -> str:
+    safe_fragment = sanitize_html_fragment(fragment)
+    return (
+        '<!DOCTYPE html><html><head><meta charset="utf-8"></head>'
+        '<body style="font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;'
+        'font-size:14px;color:#222;line-height:1.6;">'
+        f"{safe_fragment}</body></html>"
+    )
+
+
+def signature_from_config(config: dict | None, *, fallback: str = "") -> str:
+    metadata = (config or {}).get("metadata")
+    if not isinstance(metadata, dict):
+        account = (config or {}).get("agent_account")
+        if isinstance(account, dict):
+            metadata = account.get("metadata")
+    if not isinstance(metadata, dict):
+        metadata = {}
+    signature = str(metadata.get("signature") or "").strip()
+    return signature or str(fallback or "").strip()
+
+
+def append_signature_text(body_text: str, signature: str) -> str:
+    clean_body = str(body_text or "").strip()
+    clean_signature = str(signature or "").strip()
+    if not clean_signature:
+        return clean_body
+    if clean_signature in clean_body[-500:]:
+        return clean_body
+    return f"{clean_body}\n\n-- \n{clean_signature}".strip()
+
+
+def append_signature_html(fragment: str, signature: str) -> str:
+    clean_signature = str(signature or "").strip()
+    if not clean_signature:
+        return fragment
+    safe_signature = text_to_html_fragment(clean_signature)
+    return (
+        f"{fragment}"
+        '<hr style="border:none;border-top:1px solid #ddd;margin:20px 0;">'
+        f'<div style="color:#666;font-size:12px;">{safe_signature}</div>'
+    )
+
+
+def build_email_presentation(
+    *,
+    subject: str,
+    body_text: str = "",
+    body_html: str = "",
+    signature: str = "",
+    include_signature: bool = False,
+) -> EmailPresentation:
+    clean_subject = " ".join(str(subject or "").split()).strip()
+    raw_text = str(body_text or "").strip()
+    raw_html = str(body_html or "").strip()
+    input_format = "html" if raw_html else "text"
+    text = raw_text or html_to_text(raw_html)
+    html_fragment = sanitize_html_fragment(raw_html) if raw_html else text_to_html_fragment(text)
+    if include_signature:
+        text = append_signature_text(text, signature)
+        html_fragment = append_signature_html(html_fragment, signature)
+    return EmailPresentation(
+        subject=clean_subject,
+        body_text=text,
+        body_html=compose_html_document(html_fragment),
+        input_format=input_format,
+    )
+
+
+def normalize_agent_email_payload(payload: dict[str, Any], *, signature: str = "") -> EmailPresentation:
+    subject = str(payload.get("subject") or "").strip()
+    body_text = str(payload.get("body_text") or payload.get("body") or "").strip()
+    body_html = str(payload.get("body_html") or "").strip()
+    presentation = build_email_presentation(
+        subject=subject,
+        body_text=body_text,
+        body_html=body_html,
+        signature=signature,
+        include_signature=bool(signature),
+    )
+    if not presentation.subject or not presentation.body_text:
+        raise RuntimeError("Email payload is missing subject/body_text.")
+    return presentation
+
+
+__all__ = [
+    "EmailPresentation",
+    "append_signature_html",
+    "append_signature_text",
+    "build_email_presentation",
+    "compose_html_document",
+    "html_to_text",
+    "normalize_agent_email_payload",
+    "sanitize_html_fragment",
+    "signature_from_config",
+    "text_to_html_fragment",
+]

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)