nexo-brain 7.30.8 → 7.30.10

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.8",
+  "version": "7.30.10",
   "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.30.8` is the current packaged-runtime line. Patch release over v7.30.7 - Deep Sleep now folds parallel Codex sub-agents into their parent thread and Local Context stops the `entity_facts` cartesian blow-up that created runaway sidecar databases.
+Version `7.30.10` is the current packaged-runtime line. Patch release over v7.30.9 - packaged `nexo update` now stamps the verified repair baseline after import verification, including same-version maintenance runs.
+
+Previously in `7.30.9`: patch release over v7.30.8 - post-update self-heal now stamps a verified repair baseline, and doctor release gates distinguish current installation failures from historical operator/session drift.
+
+Previously in `7.30.8`: patch release over v7.30.7 - Deep Sleep now folds parallel Codex sub-agents into their parent thread and Local Context stops the `entity_facts` cartesian blow-up that created runaway sidecar databases.
 
 Previously in `7.30.7`: patch release over v7.30.6 - the Deep Sleep retention update is republished with the required release smoke contract so final closeout, npm, GitHub, and runtime verification stay aligned.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.8",
+  "version": "7.30.10",
   "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

@@ -70,6 +70,7 @@ DATA_DIR.mkdir(parents=True, exist_ok=True)
 SRC_DIR = Path(__file__).resolve().parent
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(SRC_DIR)))
 REPO_DIR = SRC_DIR.parent
+REPAIR_BASELINE_FILE = "last-repair-baseline.json"
 
 
 def _resolve_repo_dir() -> Path:
@@ -90,6 +91,22 @@ def _resolve_repo_dir() -> Path:
 
 _RESOLVED_REPO_DIR = _resolve_repo_dir()
 
+
+def _stamp_runtime_repair_baseline(dest: Path) -> str:
+    operations_dir = dest / "operations"
+    operations_dir.mkdir(parents=True, exist_ok=True)
+    now = time.time()
+    payload = {
+        "last_repair_epoch": now,
+        "last_repair_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now)),
+        "source": "auto_update._run_runtime_post_sync",
+        "reason": "verified runtime repair baseline after update/post-sync",
+    }
+    (operations_dir / REPAIR_BASELINE_FILE).write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n"
+    )
+    return "runtime-repair-baseline"
+
 LAST_CHECK_FILE = DATA_DIR / "auto_update_last_check.json"
 MIGRATION_VERSION_FILE = DATA_DIR / "migration_version"
 CLAUDE_MD_VERSION_FILE = DATA_DIR / "claude_md_version.txt"
@@ -5210,6 +5227,10 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     if verify.returncode != 0:
         return False, [verify.stderr.strip() or verify.stdout.strip() or "import verify failed"]
     actions.append("verify")
+    try:
+        actions.append(_stamp_runtime_repair_baseline(dest))
+    except Exception as exc:
+        actions.append(f"runtime-repair-baseline-warning:{exc.__class__.__name__}")
     return True, actions
 
 

package/src/doctor/models.py

@@ -17,6 +17,7 @@ class DoctorCheck:
     repair_plan: list[str] = field(default_factory=list)
     escalation_prompt: str = ""
     fixed: bool = False
+    category: str = "installed_product"  # installed_product, operator_history
 
 
 @dataclass

package/src/doctor/orchestrator.py

@@ -46,7 +46,7 @@ def run_doctor(tier: str = "boot", fix: bool = False, plane: str = "") -> Doctor
         report.duration_ms = int((time.monotonic() - start) * 1000)
         return report
 
-    _, preflight = diagnostic_plane_preflight(plane)
+    normalized_plane, preflight = diagnostic_plane_preflight(plane)
     if preflight is not None:
         report.add(preflight)
         report.compute_status()
@@ -60,7 +60,7 @@ def run_doctor(tier: str = "boot", fix: bool = False, plane: str = "") -> Doctor
         if not runner:
             continue
         try:
-            checks = runner(fix=fix)
+            checks = runner(fix=fix, plane=normalized_plane)
             for check in checks:
                 report.add(check)
         except Exception as exc:

package/src/doctor/providers/boot.py

@@ -899,7 +899,7 @@ def check_f06_migration_consistency() -> DoctorCheck:
     )
 
 
-def run_boot_checks(fix: bool = False) -> list[DoctorCheck]:
+def run_boot_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all boot-tier checks."""
     checks = [
         safe_check(check_db_exists),

package/src/doctor/providers/deep.py

@@ -357,7 +357,7 @@ def check_learning_count() -> DoctorCheck:
         )
 
 
-def run_deep_checks(fix: bool = False) -> list[DoctorCheck]:
+def run_deep_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all deep-tier checks. Read-only."""
     return [
         safe_check(check_self_audit_summary),

package/src/doctor/providers/runtime.py

@@ -64,6 +64,47 @@ CORE_AUTOMATION_CALLERS_BY_CRON = {
     "morning-agent": ("morning_agent",),
     "sleep": ("sleep/nightly",),
 }
+REPAIR_BASELINE_FILE = "last-repair-baseline.json"
+
+
+def _post_update_repair_baseline_epoch() -> float:
+    path = paths.operations_dir() / REPAIR_BASELINE_FILE
+    if not path.is_file():
+        return 0.0
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return 0.0
+    if not isinstance(payload, dict):
+        return 0.0
+    for key in ("last_repair_epoch", "timestamp_epoch"):
+        try:
+            value = float(payload.get(key) or 0)
+        except Exception:
+            value = 0.0
+        if value > 0:
+            return value
+    raw_iso = str(payload.get("last_repair_at") or payload.get("timestamp") or "").strip()
+    if not raw_iso:
+        return 0.0
+    try:
+        parsed = dt.datetime.fromisoformat(raw_iso.replace("Z", "+00:00"))
+    except Exception:
+        return 0.0
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return parsed.timestamp()
+
+
+def _history_cutoff_epoch(*, days: int) -> float:
+    return max(time.time() - (days * 86400), _post_update_repair_baseline_epoch())
+
+
+def _history_baseline_sqlite() -> str:
+    epoch = _post_update_repair_baseline_epoch()
+    if epoch <= 0:
+        return ""
+    return dt.datetime.fromtimestamp(epoch, tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
 
 
 def _evolution_objective_payload() -> dict:
@@ -271,7 +312,7 @@ def _recent_codex_session_parity_status(*, days: int = 7, max_files: int = 24) -
         Path.home() / ".codex" / "sessions",
         Path.home() / ".codex" / "archived_sessions",
     ]
-    cutoff = time.time() - (days * 86400)
+    cutoff = _history_cutoff_epoch(days=days)
     candidates: list[tuple[float, Path]] = []
     for root in roots:
         if not root.exists():
@@ -288,6 +329,7 @@ def _recent_codex_session_parity_status(*, days: int = 7, max_files: int = 24) -
 
     status = {
         "files": len(files),
+        "history_baseline_epoch": _post_update_repair_baseline_epoch(),
         "bootstrap_sessions": 0,
         "startup_sessions": 0,
         "heartbeat_sessions": 0,
@@ -578,7 +620,7 @@ def _recent_codex_conditioned_file_discipline_status(*, days: int = 7, max_files
         Path.home() / ".codex" / "sessions",
         Path.home() / ".codex" / "archived_sessions",
     ]
-    cutoff = time.time() - (days * 86400)
+    cutoff = _history_cutoff_epoch(days=days)
     candidates: list[tuple[float, Path]] = []
     for root in roots:
         if not root.exists():
@@ -593,6 +635,7 @@ def _recent_codex_conditioned_file_discipline_status(*, days: int = 7, max_files
     candidates.sort(key=lambda item: item[0], reverse=True)
     files = candidates[:max_files]
     status["files"] = len(files)
+    status["history_baseline_epoch"] = _post_update_repair_baseline_epoch()
 
     for file_mtime, path in files:
         cwd = ""
@@ -2312,6 +2355,7 @@ def check_codex_session_parity() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Codex session parity check skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_session_parity_status()
@@ -2329,6 +2373,7 @@ def check_codex_session_parity() -> DoctorCheck:
                 "Codex is selected, but there are no recent durable Codex sessions to inspect. "
                 "NEXO cannot prove that manual Codex sessions are entering the shared-brain startup flow."
             ),
+            category="operator_history",
         )
 
     evidence = [
@@ -2378,6 +2423,7 @@ def check_codex_session_parity() -> DoctorCheck:
             "Codex is selected, but recent durable Codex sessions are not consistently showing NEXO bootstrap markers or `nexo_startup`. "
             "Manual Codex sessions may still be starting too plain."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2400,6 +2446,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Startup reachability skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_session_parity_status(days=1, max_files=48)
@@ -2425,6 +2472,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
             evidence=evidence,
             repair_plan=["Start Codex through the managed NEXO launcher and re-run doctor"],
             escalation_prompt="NEXO cannot prove recent Codex sessions reached startup.",
+            category="operator_history",
         )
 
     status = "healthy" if missing == 0 else "critical"
@@ -2447,6 +2495,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
         escalation_prompt=(
             "Codex sessions are starting without the shared-brain startup step, so memory/guard continuity is not guaranteed."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2468,6 +2517,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Codex conditioned-file discipline check skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_conditioned_file_discipline_status()
@@ -2491,6 +2541,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             severity="info",
             summary="No active conditioned-file learnings defined for Codex session audits",
             evidence=evidence,
+            category="operator_history",
         )
 
     if audit["files"] == 0 or audit["conditioned_sessions"] == 0:
@@ -2501,6 +2552,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             severity="info",
             summary="No conditioned-file touches seen in recent Codex sessions",
             evidence=evidence + [f"conditioned touches: {audit['conditioned_touches']}"],
+            category="operator_history",
         )
 
     evidence.extend([
@@ -2595,10 +2647,11 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             "Codex sessions are touching conditioned files without the expected protocol/guard sequence. "
             "Until this is clean, parity with Claude hooks is still incomplete."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
-def check_codex_protocol_compliance() -> DoctorCheck:
+def check_codex_protocol_compliance(include_history: bool = True) -> DoctorCheck:
     try:
         schedule = _load_json(SCHEDULE_FILE) if SCHEDULE_FILE.is_file() else {}
     except Exception:
@@ -2646,6 +2699,16 @@ def check_codex_protocol_compliance() -> DoctorCheck:
             ),
         )
 
+    if not include_history:
+        return DoctorCheck(
+            id="installation_live.codex_protocol_compliance",
+            tier="runtime",
+            status="healthy",
+            severity="info",
+            summary="Codex live protocol enforcement is installed",
+            evidence=[f"codex PreToolUse hook: managed ({hooks.get('pretool_matcher') or '*'})"],
+        )
+
     startup = _recent_codex_session_parity_status(days=1)
     conditioned = _recent_codex_conditioned_file_discipline_status(days=1)
     sessions = int(startup.get("files") or conditioned.get("files") or 0)
@@ -2659,6 +2722,7 @@ def check_codex_protocol_compliance() -> DoctorCheck:
             repair_plan=[
                 "Run Codex through the managed NEXO bootstrap so doctor can verify live protocol compliance",
             ],
+            category="operator_history",
         )
 
     startup_violation_sessions = 0
@@ -2709,6 +2773,7 @@ def check_codex_protocol_compliance() -> DoctorCheck:
         escalation_prompt=(
             "Codex CLI parity is not clean: recent sessions miss startup/heartbeat or bypass conditioned-file guard discipline."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2898,11 +2963,14 @@ def check_protocol_compliance() -> DoctorCheck:
                 debt_rows = None
                 if {"protocol_tasks", "protocol_debt"}.issubset(tables):
                     window = "-7 days"
+                    history_floor = _history_baseline_sqlite()
+                    task_floor_clause = " AND opened_at >= ?" if history_floor else ""
+                    task_params = (window, history_floor) if history_floor else (window,)
                     tasks = conn.execute(
-                        """SELECT * FROM protocol_tasks
-                           WHERE opened_at >= datetime('now', ?)
+                        f"""SELECT * FROM protocol_tasks
+                           WHERE opened_at >= datetime('now', ?){task_floor_clause}
                            ORDER BY opened_at DESC""",
-                        (window,),
+                        task_params,
                     ).fetchall()
                     protocol_debt_cols = {
                         row["name"] for row in conn.execute("PRAGMA table_info(protocol_debt)").fetchall()
@@ -2946,6 +3014,8 @@ def check_protocol_compliance() -> DoctorCheck:
                         task_status_expr = "'' AS task_status"
                         if "status" in protocol_task_cols:
                             task_status_expr = "pt.status AS task_status"
+                        debt_floor_clause = " AND pd.created_at >= ?" if history_floor else ""
+                        debt_params = (window, history_floor) if history_floor else (window,)
                         open_debts = conn.execute(
                             f"""SELECT
                                     pd.severity,
@@ -2956,9 +3026,9 @@ def check_protocol_compliance() -> DoctorCheck:
                                     {task_status_expr}
                                 FROM protocol_debt pd
                                 LEFT JOIN protocol_tasks pt ON pt.task_id = pd.task_id
-                                WHERE pd.status = 'open' AND pd.created_at >= datetime('now', ?)
+                                WHERE pd.status = 'open' AND pd.created_at >= datetime('now', ?){debt_floor_clause}
                                 ORDER BY pd.created_at DESC""",
-                            (window,),
+                            debt_params,
                         ).fetchall()
                         debt_counter: dict[tuple[str, str], int] = {}
                         for row in open_debts:
@@ -2987,12 +3057,13 @@ def check_protocol_compliance() -> DoctorCheck:
                     else:
                         debt_rows = [
                             dict(row) for row in conn.execute(
-                                """SELECT severity, debt_type, COUNT(*) AS total
+                                f"""SELECT severity, debt_type, COUNT(*) AS total
                                    FROM protocol_debt
                                    WHERE status = 'open' AND created_at >= datetime('now', ?)
+                                   {"AND created_at >= ?" if history_floor else ""}
                                    GROUP BY severity, debt_type
                                    ORDER BY total DESC, debt_type ASC""",
-                                (window,),
+                                (window, history_floor) if history_floor else (window,),
                             ).fetchall()
                         ]
                     has_cortex_evaluations = bool(
@@ -3010,16 +3081,33 @@ def check_protocol_compliance() -> DoctorCheck:
                             ).fetchall()
                         }
                         first_eval_row = conn.execute(
-                            """SELECT MIN(created_at) AS first_eval
+                            f"""SELECT MIN(created_at) AS first_eval
                                FROM cortex_evaluations
-                               WHERE created_at >= datetime('now', ?)""",
-                            (window,),
+                               WHERE created_at >= datetime('now', ?)
+                               {"AND created_at >= ?" if history_floor else ""}""",
+                            (window, history_floor) if history_floor else (window,),
                         ).fetchone()
                         if first_eval_row and first_eval_row["first_eval"]:
                             first_cortex_eval_at = str(first_eval_row["first_eval"])
             finally:
                 conn.close()
 
+            history_floor = _history_baseline_sqlite()
+            if tasks is not None and debt_rows is not None and not tasks and not debt_rows and history_floor:
+                return DoctorCheck(
+                    id="runtime.protocol_compliance",
+                    tier="runtime",
+                    status="healthy",
+                    severity="info",
+                    summary="No protocol drift after the last verified runtime repair",
+                    evidence=[
+                        "live protocol window: 7d",
+                        f"post-update repair baseline: {history_floor}",
+                        "no protocol tasks or open debt after repair baseline",
+                    ],
+                    category="operator_history",
+                )
+
             if tasks is not None and debt_rows is not None and (tasks or debt_rows):
                     closed_tasks = [row for row in tasks if row["status"] != "open"]
                     verify_required = [row for row in closed_tasks if row["must_verify"] and row["status"] == "done"]
@@ -3122,6 +3210,7 @@ def check_protocol_compliance() -> DoctorCheck:
                         escalation_prompt=(
                             "Task discipline is drifting in live runtime data. NEXO is still skipping verification, change logging, or correction capture."
                         ) if status != "healthy" else "",
+                        category="operator_history",
                     )
     except Exception:
         pass
@@ -3140,6 +3229,7 @@ def check_protocol_compliance() -> DoctorCheck:
             escalation_prompt=(
                 "NEXO cannot verify heartbeat / guard_check / change_log compliance because the latest weekly Deep Sleep summary is missing."
             ),
+            category="operator_history",
         )
 
     protocol = summary.get("protocol_summary") or {}
@@ -3197,6 +3287,7 @@ def check_protocol_compliance() -> DoctorCheck:
         escalation_prompt=(
             "Heartbeat / guard_check / change_log discipline is drifting. NEXO is at risk of repeating known errors and hiding change history."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -3979,9 +4070,15 @@ def check_memory_fabric_health(fix: bool = False) -> DoctorCheck:
         )
 
 
-def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
+def _filter_runtime_checks_for_plane(checks: list[DoctorCheck], plane: str = "") -> list[DoctorCheck]:
+    if plane == "installation_live":
+        return [check for check in checks if check.category != "operator_history"]
+    return checks
+
+
+def run_runtime_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
-    return [
+    checks = [
         safe_check(check_immune_status),
         safe_check(check_watchdog_status),
         safe_check(check_runner_health_status),
@@ -3992,7 +4089,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_codex_session_parity),
         safe_check(check_bootstrap_reached_startup),
         safe_check(check_codex_conditioned_file_discipline),
-        safe_check(check_codex_protocol_compliance),
+        safe_check(check_codex_protocol_compliance, include_history=plane != "installation_live"),
         safe_check(check_claude_desktop_shared_brain),
         safe_check(check_transcript_source_parity),
         safe_check(check_client_assumption_regressions),
@@ -4009,3 +4106,4 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_personal_script_registry, fix=fix),
         safe_check(check_skill_health, fix=fix),
     ]
+    return _filter_runtime_checks_for_plane(checks, plane=plane)

package/src/plugins/update.py

@@ -152,6 +152,23 @@ NEXO_HOME = export_resolved_nexo_home()
 DATA_DIR = paths.data_dir()
 BACKUP_BASE = paths.backups_dir()
 TECHNICAL_BACKUP_KEEP = 5
+REPAIR_BASELINE_FILE = "last-repair-baseline.json"
+
+
+def _stamp_runtime_repair_baseline(source: str = "plugins.update") -> str:
+    operations_dir = NEXO_HOME / "operations"
+    operations_dir.mkdir(parents=True, exist_ok=True)
+    now = time.time()
+    payload = {
+        "last_repair_epoch": now,
+        "last_repair_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now)),
+        "source": source,
+        "reason": "verified runtime repair baseline after update/post-sync",
+    }
+    (operations_dir / REPAIR_BASELINE_FILE).write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n"
+    )
+    return "runtime-repair-baseline"
 
 
 def _env_int(name: str, default: int) -> int:
@@ -1454,6 +1471,13 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
     verify_err = _verify_import()
     if verify_err:
         errors.append(f"verification: {verify_err}")
+    repair_baseline_warning = None
+    if not verify_err:
+        try:
+            _emit_progress(progress_fn, "Stamping runtime repair baseline...")
+            _stamp_runtime_repair_baseline("plugins.update._handle_packaged_update")
+        except Exception as exc:
+            repair_baseline_warning = f"{exc.__class__.__name__}: {exc}"
 
     hook_sync_warning = None
     cron_sync_warning = None
@@ -1616,6 +1640,10 @@ def _handle_packaged_update(progress_fn=None, *, include_clis: bool = True) -> s
         lines.append("  Clients: configured client targets synced")
     else:
         lines.append(f"  WARNING: client sync: {client_sync_warning}")
+    if not repair_baseline_warning:
+        lines.append("  Repair baseline: updated")
+    else:
+        lines.append(f"  WARNING: repair baseline: {repair_baseline_warning}")
     if launchagent_reload_summary and launchagent_reload_summary.get("scanned"):
         if not launchagent_reload_warning:
             lines.append(
@@ -1765,6 +1793,12 @@ def handle_update(
         if verify_err:
             raise RuntimeError(f"Verification failed: {verify_err}")
         steps_done.append("verify")
+        try:
+            _emit_progress(progress_fn, "Stamping runtime repair baseline...")
+            _stamp_runtime_repair_baseline("plugins.update.handle_update")
+            steps_done.append("runtime-repair-baseline")
+        except Exception as e:
+            steps_done.append(f"runtime-repair-baseline-warning:{e.__class__.__name__}")
 
         # Step 8: Sync crons with manifest
         cron_sync_result = ""
@@ -1929,6 +1963,8 @@ def handle_update(
                 trailing.insert(2 if len(trailing) >= 2 else len(trailing), "  Crons: synced with manifest")
             if "client-sync" in steps_done:
                 trailing.append("  Clients: configured client targets synced")
+            if "runtime-repair-baseline" in steps_done:
+                trailing.append("  Repair baseline: updated")
             if trailing:
                 msg += "\n" + "\n".join(trailing)
             return msg
@@ -1954,6 +1990,8 @@ def handle_update(
         lines.extend(external_cli_lines)
         if "client-sync" in steps_done:
             lines.append("  Clients: configured client targets synced")
+        if "runtime-repair-baseline" in steps_done:
+            lines.append("  Repair baseline: updated")
         if versioned_runtime_summary and versioned_runtime_summary.get("ok"):
             lines.append(f"  Runtime activation: core/current -> versions/{new_version}")
         if version_prune_summary and version_prune_summary.get("pruned"):