nexo-brain 5.3.11 → 5.3.13

package/src/plugins/doctor.py

@@ -11,13 +11,14 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 
-def handle_doctor(tier: str = "boot", fix: bool = False, output: str = "text") -> str:
+def handle_doctor(tier: str = "boot", fix: bool = False, output: str = "text", plane: str = "") -> str:
     """Unified diagnostic report for boot/runtime/deep health.
 
     Args:
         tier: Diagnostic tier — boot, runtime, deep, or all (default: boot)
         fix: Apply deterministic fixes (default: False)
         output: Output format — text or json (default: text)
+        plane: Diagnostic plane — runtime_personal, installation_live, or database_real
     """
     from doctor.orchestrator import run_doctor
     from doctor.formatters import format_report
@@ -27,7 +28,7 @@ def handle_doctor(tier: str = "boot", fix: bool = False, output: str = "text") -
     if output not in ("text", "json"):
         return f"Invalid output '{output}'. Use: text, json"
 
-    report = run_doctor(tier=tier, fix=fix)
+    report = run_doctor(tier=tier, fix=fix, plane=plane)
     return format_report(report, fmt=output)
 
 

package/src/plugins/schedule.py

@@ -20,6 +20,9 @@ from script_registry import (
     get_declared_schedule,
 )
 
+LEGACY_BACKUP_CRON_ID = "backup"
+LEGACY_BACKUP_SUMMARY = "legacy backup file evidence"
+
 
 def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
     """Show cron execution status — what ran, what failed, durations.
@@ -30,6 +33,8 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
     """
     if cron_id:
         runs = cron_runs_recent(hours, cron_id)
+        if cron_id == LEGACY_BACKUP_CRON_ID:
+            runs = _select_backup_runs(runs, hours)
         if not runs:
             return f"No runs for '{cron_id}' in the last {hours}h."
         schedule_meta = get_personal_script_schedule(cron_id) or {}
@@ -53,7 +58,7 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
         return "\n".join(lines)
 
     # Summary view — one line per cron
-    summary = cron_runs_summary(hours)
+    summary = _merge_legacy_summaries(cron_runs_summary(hours), hours)
     if not summary:
         return f"No cron executions recorded in the last {hours}h."
 
@@ -82,6 +87,119 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
     return "\n".join(lines)
 
 
+def _select_backup_runs(db_runs: list[dict], hours: int) -> list[dict]:
+    legacy_runs = _legacy_backup_runs(hours)
+    if _prefer_legacy_over_db(db_runs, legacy_runs):
+        return legacy_runs
+    return db_runs
+
+
+def _merge_legacy_summaries(summary_rows: list[dict], hours: int) -> list[dict]:
+    rows = [dict(row) for row in (summary_rows or [])]
+    legacy_summary = _legacy_backup_summary(hours)
+    if not legacy_summary:
+        return rows
+    by_cron_id = {row["cron_id"]: row for row in rows}
+    existing = by_cron_id.get(LEGACY_BACKUP_CRON_ID)
+    if _prefer_legacy_summary(existing, legacy_summary):
+        by_cron_id[LEGACY_BACKUP_CRON_ID] = legacy_summary
+    return sorted(
+        by_cron_id.values(),
+        key=lambda row: row.get("last_run") or "",
+        reverse=True,
+    )
+
+
+def _prefer_legacy_over_db(db_runs: list[dict], legacy_runs: list[dict]) -> bool:
+    if not legacy_runs:
+        return False
+    if not db_runs:
+        return True
+    latest_db = _parse_db_timestamp(db_runs[0].get("started_at"))
+    latest_legacy = _parse_db_timestamp(legacy_runs[0].get("started_at"))
+    if latest_legacy is None:
+        return False
+    if latest_db is None:
+        return True
+    return latest_legacy > latest_db
+
+
+def _prefer_legacy_summary(existing: dict | None, legacy: dict) -> bool:
+    if not legacy:
+        return False
+    if not existing:
+        return True
+    latest_existing = _parse_db_timestamp(existing.get("last_run"))
+    latest_legacy = _parse_db_timestamp(legacy.get("last_run"))
+    if latest_legacy is None:
+        return False
+    if latest_existing is None:
+        return True
+    return latest_legacy > latest_existing
+
+
+def _legacy_backup_summary(hours: int) -> dict | None:
+    runs = _legacy_backup_runs(hours)
+    if not runs:
+        return None
+    return _build_summary_from_runs(LEGACY_BACKUP_CRON_ID, runs)
+
+
+def _legacy_backup_runs(hours: int) -> list[dict]:
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    backup_dir = nexo_home / "backups"
+    if not backup_dir.exists():
+        return []
+    cutoff = _now_utc().timestamp() - (hours * 3600)
+    runs: list[dict] = []
+    for backup_file in backup_dir.glob("nexo-*.db"):
+        try:
+            stat = backup_file.stat()
+        except OSError:
+            continue
+        if stat.st_mtime < cutoff:
+            continue
+        started = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).replace(microsecond=0)
+        started_at = started.strftime("%Y-%m-%d %H:%M:%S")
+        runs.append(
+            {
+                "cron_id": LEGACY_BACKUP_CRON_ID,
+                "started_at": started_at,
+                "ended_at": started_at,
+                "exit_code": 0,
+                "summary": LEGACY_BACKUP_SUMMARY,
+                "error": "",
+                "duration_secs": 1.0,
+            }
+        )
+    runs.sort(key=lambda row: row["started_at"], reverse=True)
+    return runs
+
+
+def _build_summary_from_runs(cron_id: str, runs: list[dict]) -> dict:
+    completed_runs = [
+        row for row in runs if row.get("exit_code") is not None and row.get("ended_at")
+    ]
+    duration_values = [
+        float(row["duration_secs"])
+        for row in completed_runs
+        if row.get("duration_secs") is not None
+    ]
+    return {
+        "cron_id": cron_id,
+        "total_runs": len(runs),
+        "succeeded": sum(1 for row in completed_runs if row.get("exit_code") == 0),
+        "completed_runs": len(completed_runs),
+        "failed": sum(1 for row in completed_runs if row.get("exit_code") not in (None, 0)),
+        "open_runs": len(runs) - len(completed_runs),
+        "avg_duration": round(sum(duration_values) / len(duration_values), 1) if duration_values else None,
+        "last_run": runs[0].get("started_at"),
+        "last_exit_code": runs[0].get("exit_code"),
+        "last_ended_at": runs[0].get("ended_at"),
+        "last_summary": next((row.get("summary") for row in runs if row.get("summary")), ""),
+    }
+
+
 def _summary_has_warning(summary: str = "") -> bool:
     lowered = str(summary or "").strip().lower()
     if not lowered:

package/src/runtime_power.py

@@ -67,8 +67,9 @@ MACOS_FDA_PROBE_PATHS = (
 )
 DEFAULT_CLAUDE_CODE_MODEL = "claude-opus-4-6[1m]"
 DEFAULT_CLAUDE_CODE_REASONING_EFFORT = ""
-DEFAULT_CODEX_MODEL = "gpt-5.4"
-DEFAULT_CODEX_REASONING_EFFORT = "xhigh"
+# Codex defaults mirror the user's primary model — no hardcoded third-party models.
+DEFAULT_CODEX_MODEL = DEFAULT_CLAUDE_CODE_MODEL
+DEFAULT_CODEX_REASONING_EFFORT = ""
 
 
 def _schedule_defaults() -> dict:

package/src/scripts/check-context.py

@@ -21,6 +21,12 @@ if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 
 
 class ContextChecker:
@@ -192,7 +198,7 @@ Rules:
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=300,
             output_format="text",
             append_system_prompt="Return exactly one valid JSON object.",

package/src/scripts/deep-sleep/extract.py

@@ -26,6 +26,12 @@ if str(NEXO_CODE) not in sys.path:
     sys.path.insert(0, str(NEXO_CODE))
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 
 # No timeout -- headless automation can take as long as needed
 CLAUDE_TIMEOUT = 21600  # 3h safety net (prevents zombie processes)
@@ -128,7 +134,7 @@ def analyze_session(
 
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=CLAUDE_TIMEOUT,
             output_format="text",
             append_system_prompt=JSON_SYSTEM_PROMPT,
@@ -158,7 +164,7 @@ def analyze_session(
             )
             convert_result = run_automation_prompt(
                 convert_prompt,
-                model="sonnet",
+                model=_USER_MODEL or "sonnet",
                 timeout=120,
                 output_format="text",
                 append_system_prompt=JSON_SYSTEM_PROMPT,

package/src/scripts/deep-sleep/synthesize.py

@@ -18,6 +18,13 @@ import hashlib
 from datetime import datetime
 from pathlib import Path
 
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parents[2])))
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
@@ -233,7 +240,7 @@ def main():
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=CLAUDE_TIMEOUT,
             output_format="text",
             allowed_tools="Read,Grep,Bash",

package/src/scripts/nexo-catchup.py

@@ -13,6 +13,13 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 _SCRIPT_DIR = Path(__file__).resolve().parent
 _DEFAULT_RUNTIME_ROOT = _SCRIPT_DIR.parent
 _runtime_root = Path(os.environ.get("NEXO_CODE", str(_DEFAULT_RUNTIME_ROOT)))
@@ -126,7 +133,6 @@ def _heal_personal_schedules() -> dict:
     summary = {"created": 0, "repaired": 0, "invalid": 0, "error": ""}
     try:
         from script_registry import reconcile_personal_scripts
-
         result = reconcile_personal_scripts(dry_run=False)
         ensured = result.get("ensure_schedules", {})
         summary["created"] = len(ensured.get("created", []))
@@ -273,7 +279,7 @@ Format:
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=21600,
             output_format="text",
             allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",

package/src/scripts/nexo-cortex-cycle.py

@@ -18,9 +18,9 @@ What this script does (idempotent and best-effort):
 3. Detects degradation signals on the 7-day window. The criteria are
    intentionally conservative to avoid false alarms on small samples:
      a. recommendation_accept_rate < 50% AND total_evaluations >= 10
-     b. linked_outcome_success_rate < 50% AND linked_outcomes_total >= 5
+     b. linked_outcome_success_rate < 50% AND linked_outcomes_resolved >= 5
      c. override_success_rate > recommended_success_rate by >= 20pp
-        AND linked_outcomes_total >= 5
+        AND linked_outcomes_resolved >= 5
 4. Opens (or refreshes) NF-CORTEX-QUALITY-DROP followup with the offending
    metrics when degradation is detected. Idempotent: if a non-PENDING /
    resolved followup of the same id already exists, it is updated in
@@ -96,6 +96,13 @@ def detect_quality_signals(summary: dict) -> list[dict]:
     total = int(summary.get("total_evaluations") or 0)
     accept_rate = float(summary.get("recommendation_accept_rate") or 0.0)
     linked_total = int(summary.get("linked_outcomes_total") or 0)
+    linked_met = int(summary.get("linked_outcomes_met") or 0)
+    linked_missed = int(summary.get("linked_outcomes_missed") or 0)
+    linked_pending = int(summary.get("linked_outcomes_pending") or 0)
+    linked_resolved = linked_met + linked_missed
+    if linked_resolved <= 0 and linked_total > 0:
+        # Older callers may omit the met/missed counters; fall back to total minus pending.
+        linked_resolved = max(0, linked_total - linked_pending)
     linked_success = float(summary.get("linked_outcome_success_rate") or 0.0)
     recommended_success = float(summary.get("recommended_success_rate") or 0.0)
     override_success = float(summary.get("override_success_rate") or 0.0)
@@ -114,21 +121,25 @@ def detect_quality_signals(summary: dict) -> list[dict]:
             ),
         })
 
-    if linked_total >= LINKED_MIN_SAMPLE and linked_success < LINKED_SUCCESS_FLOOR:
+    linked_scope = f"{linked_resolved} resolved linked outcomes"
+    if linked_pending > 0:
+        linked_scope += f" ({linked_total} total, {linked_pending} pending)"
+
+    if linked_resolved >= LINKED_MIN_SAMPLE and linked_success < LINKED_SUCCESS_FLOOR:
         signals.append({
             "kind": "linked_success",
             "severity": "warn",
             "metric_value": linked_success,
             "threshold": LINKED_SUCCESS_FLOOR,
-            "sample_size": linked_total,
+            "sample_size": linked_resolved,
             "message": (
                 f"Cortex linked-outcome success rate {linked_success:.1f}% on "
-                f"{linked_total} linked outcomes is below the "
+                f"{linked_scope} is below the "
                 f"{LINKED_SUCCESS_FLOOR:.0f}% floor."
             ),
         })
 
-    if linked_total >= LINKED_MIN_SAMPLE:
+    if linked_resolved >= LINKED_MIN_SAMPLE:
         gap = override_success - recommended_success
         if gap >= OVERRIDE_GAP_THRESHOLD:
             signals.append({
@@ -136,12 +147,12 @@ def detect_quality_signals(summary: dict) -> list[dict]:
                 "severity": "error",
                 "metric_value": gap,
                 "threshold": OVERRIDE_GAP_THRESHOLD,
-                "sample_size": linked_total,
+                "sample_size": linked_resolved,
                 "message": (
                     f"Cortex overrides outperform recommendations by {gap:.1f}pp "
                     f"(override {override_success:.1f}% vs recommended "
-                    f"{recommended_success:.1f}% on {linked_total} linked "
-                    "outcomes). The recommender is mis-ranking choices."
+                    f"{recommended_success:.1f}% on {linked_scope}). The "
+                    "recommender is mis-ranking choices."
                 ),
             })
 
@@ -171,15 +182,37 @@ def _upsert_quality_followup(signals: list[dict]) -> str:
     resolved, a fresh row is inserted with the same id (REPLACE) so the
     new degradation pattern is visible.
     """
-    if not signals:
-        return "no_signal"
-
     try:
-        from db import get_followup, get_db
+        from db import complete_followup, get_followup, get_db
     except Exception as e:
         _log(f"WARN: cannot import db helpers: {e}")
         return "skipped_no_db"
 
+    try:
+        existing = get_followup(FOLLOWUP_ID)
+    except Exception as e:
+        _log(f"WARN: get_followup raised: {e}")
+        existing = None
+
+    if not signals:
+        if not existing:
+            return "no_signal"
+        status = str(existing.get("status") or "").upper()
+        if status.startswith("COMPLETED") or status in {"DELETED", "ARCHIVED", "BLOCKED", "WAITING", "CANCELLED"}:
+            return "no_signal"
+        try:
+            complete_followup(
+                FOLLOWUP_ID,
+                result=(
+                    "Auto-resolved by cortex-cycle: no active degradation signals in the "
+                    "current 7d window."
+                ),
+            )
+        except Exception as e:
+            _log(f"WARN: failed to close followup: {e}")
+            return "failed_close"
+        return "closed"
+
     summary_lines = ["Cortex continuous validation found quality degradation:"]
     for sig in signals:
         summary_lines.append(
@@ -197,12 +230,6 @@ def _upsert_quality_followup(signals: list[dict]) -> str:
     )
     now_epoch = datetime.now().timestamp()
 
-    try:
-        existing = get_followup(FOLLOWUP_ID)
-    except Exception as e:
-        _log(f"WARN: get_followup raised: {e}")
-        existing = None
-
     try:
         conn = get_db()
         conn.execute(
@@ -255,8 +282,8 @@ def run() -> int:
             f"signals={len(signals)}"
         )
 
-    if signals:
-        action = _upsert_quality_followup(signals)
+    action = _upsert_quality_followup(signals)
+    if signals or action not in {"no_signal"}:
         _log(f"Cortex cycle: followup {FOLLOWUP_ID} {action} ({len(signals)} signal(s))")
 
     return 0

package/src/scripts/nexo-daily-self-audit.py

@@ -40,6 +40,12 @@ from agent_runner import AutomationBackendUnavailableError, run_automation_promp
 import db as nexo_db
 from public_evolution_queue import queue_public_port_candidate
 
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 LOG_DIR = NEXO_HOME / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
 AUDIT_HISTORY_DIR = LOG_DIR / "self-audit"
@@ -479,6 +485,43 @@ def _upsert_workflow_goal_inline(conn: sqlite3.Connection, *, area: str, sample_
 
     columns = _table_columns(conn, "workflow_goals")
     signature = _topic_signature(sample_goal)
+    goal_id = f"WG-AUDIT-{hashlib.sha1(f'{area}:{signature or sample_goal}'.encode('utf-8'), usedforsecurity=False).hexdigest()[:8].upper()}"
+
+    def _write_goal(existing_row: sqlite3.Row, *, reactivated: bool) -> dict:
+        updates: dict[str, object] = {}
+        if "title" in columns:
+            updates["title"] = sample_goal[:140]
+        if "objective" in columns:
+            updates["objective"] = objective
+        if "priority" in columns:
+            updates["priority"] = "high"
+        if "owner" in columns:
+            updates["owner"] = AUDIT_GOAL_OWNER
+        if "next_action" in columns:
+            updates["next_action"] = next_action
+        if "success_signal" in columns:
+            updates["success_signal"] = success_signal
+        if "shared_state" in columns:
+            updates["shared_state"] = json.dumps({"area": area, "signature": signature, "source": "self-audit"})
+        if reactivated and "status" in columns:
+            updates["status"] = "active"
+        if reactivated and "blocker_reason" in columns:
+            updates["blocker_reason"] = ""
+        if reactivated and "closed_at" in columns:
+            updates["closed_at"] = None
+        if "updated_at" in columns:
+            updates["updated_at"] = now_iso
+        assignments = ", ".join(f"{column} = ?" for column in updates)
+        conn.execute(
+            f"UPDATE workflow_goals SET {assignments} WHERE goal_id = ?",
+            [updates[column] for column in updates] + [existing_row["goal_id"]],
+        )
+        return {
+            "ok": True,
+            "action": "reactivated" if reactivated else "updated",
+            "goal_id": str(existing_row["goal_id"]),
+        }
+
     rows = conn.execute(
         """SELECT * FROM workflow_goals
            WHERE status NOT IN ('completed', 'cancelled', 'abandoned')
@@ -499,31 +542,21 @@ def _upsert_workflow_goal_inline(conn: sqlite3.Connection, *, area: str, sample_
     next_action = AUDIT_GOAL_NEXT_ACTION
     success_signal = "The theme stops resurfacing in unresolved protocol tasks."
     now_iso = datetime.now().isoformat(timespec="seconds")
-    if existing:
-        updates: dict[str, object] = {}
-        if "title" in columns:
-            updates["title"] = sample_goal[:140]
-        if "objective" in columns:
-            updates["objective"] = objective
-        if "priority" in columns:
-            updates["priority"] = "high"
-        if "owner" in columns:
-            updates["owner"] = AUDIT_GOAL_OWNER
-        if "next_action" in columns:
-            updates["next_action"] = next_action
-        if "success_signal" in columns:
-            updates["success_signal"] = success_signal
-        if "updated_at" in columns:
-            updates["updated_at"] = now_iso
-        assignments = ", ".join(f"{column} = ?" for column in updates)
-        conn.execute(
-            f"UPDATE workflow_goals SET {assignments} WHERE goal_id = ?",
-            [updates[column] for column in updates] + [existing["goal_id"]],
+    exact = conn.execute(
+        "SELECT * FROM workflow_goals WHERE goal_id = ? LIMIT 1",
+        (goal_id,),
+    ).fetchone()
+    if exact is not None:
+        exact_status = str(exact["status"] or "").lower()
+        return _write_goal(
+            exact,
+            reactivated=exact_status in {"completed", "cancelled", "abandoned"},
         )
-        return {"ok": True, "action": "updated", "goal_id": str(existing["goal_id"])}
+
+    if existing:
+        return _write_goal(existing, reactivated=False)
 
     # Content fingerprint, not security-sensitive.
-    goal_id = f"WG-AUDIT-{hashlib.sha1(f'{area}:{signature or sample_goal}'.encode('utf-8'), usedforsecurity=False).hexdigest()[:8].upper()}"
     values: dict[str, object] = {"goal_id": goal_id}
     if "session_id" in columns:
         values["session_id"] = ""
@@ -2016,7 +2049,7 @@ Also write the machine-readable summary to {LOG_DIR}/self-audit-summary.json.
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=21600,
             output_format="text",
             allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",

package/src/scripts/nexo-evolution-run.py

@@ -20,6 +20,14 @@ import sys
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 # Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
 _script_dir = Path(__file__).resolve().parent
@@ -218,7 +226,7 @@ def call_claude_cli(prompt: str) -> str:
     """Call the configured automation backend for the managed evolution prompt."""
     result = run_automation_prompt(
         prompt,
-        model="opus",
+        model=_USER_MODEL or "opus",
         timeout=CLI_TIMEOUT,
         output_format="text",
         allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
@@ -234,7 +242,7 @@ def call_public_claude_cli(prompt: str, *, cwd: Path) -> str:
         prompt,
         cwd=cwd,
         env={"NEXO_PUBLIC_CONTRIBUTION": "1"},
-        model="opus",
+        model=_USER_MODEL or "opus",
         timeout=CLI_TIMEOUT,
         output_format="text",
         allowed_tools="Read,Write,Edit,Glob,Grep,Bash",

package/src/scripts/nexo-immune.py

@@ -23,6 +23,13 @@ import time
 from datetime import datetime, date, timedelta
 from pathlib import Path
 
+
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 _script_dir = Path(__file__).resolve().parent
 _repo_src = _script_dir.parent
@@ -908,7 +915,7 @@ Write the report. Be concise — max 40 lines."""
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=21600,
             output_format="text",
             allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",

package/src/scripts/nexo-learning-validator.py

@@ -37,6 +37,13 @@ if str(NEXO_CODE) not in sys.path:
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
+
 
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 JSON_ONLY_SYSTEM_PROMPT = (
@@ -151,7 +158,7 @@ Rules:
     try:
         result = run_automation_prompt(
             prompt,
-            model="sonnet",
+            model=_USER_MODEL or "sonnet",
             timeout=60,
             output_format="text",
             append_system_prompt=JSON_ONLY_SYSTEM_PROMPT,
@@ -231,6 +238,7 @@ def _extract_keywords(text: str) -> set:
 
 def main():
     import argparse
+
     parser = argparse.ArgumentParser(description="Validate findings against existing NEXO learnings")
     parser.add_argument("finding", help="The finding text to validate")
     parser.add_argument("--category", "-c", help="Filter learnings by category")

package/src/scripts/nexo-postmortem-consolidator.py

@@ -38,6 +38,13 @@ sys.path.insert(0, str(NEXO_CODE))
 
 from agent_runner import AutomationBackendUnavailableError, run_automation_prompt
 
+try:
+    from client_preferences import resolve_user_model as _resolve_user_model
+    _USER_MODEL = _resolve_user_model()
+except Exception:
+    _USER_MODEL = ""
+
+
 NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 # Memory directory — adjust to match your project's memory location
 MEMORY_DIR = NEXO_HOME / "memory"
@@ -212,7 +219,7 @@ Execute without asking."""
     try:
         result = run_automation_prompt(
             prompt,
-            model="opus",
+            model=_USER_MODEL or "opus",
             timeout=21600,
             output_format="text",
             allowed_tools="Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*",
@@ -348,6 +355,7 @@ def analyze_force_events():
     log(f"  {len(today_forces)} --force events")
 
     from collections import Counter
+
     memory_counts = Counter(r["memory_id"] for r in today_forces)
     for mem_id, count in memory_counts.most_common():
         mem = db.execute(