iints-sdk-python35 1.5.26__py3-none-any.whl → 1.5.30__py3-none-any.whl

iints/__init__.py

@@ -11,7 +11,7 @@ except ImportError:  # pragma: no cover - Python < 3.8 fallback
 try:
     __version__ = version("iints-sdk-python35")
 except PackageNotFoundError:  # pragma: no cover - source tree fallback
-    __version__ = "1.5.26"
+    __version__ = "1.5.30"
 
 # Note to developers: this SDK is currently maintained by a single author.
 # Please report bugs via GitHub issues and feel free to contribute fixes via PRs.

iints/ai/backends/ollama.py

@@ -234,15 +234,14 @@ class OllamaBackend:
                 resolved = installed_lookup.get(alias.lower())
                 if resolved is not None:
                     return resolved
-
-        for installed_name in installed:
-            lowered = installed_name.lower()
-            if "ministral-3" in lowered and "8b" in lowered:
-                return installed_name
-        for installed_name in installed:
-            lowered = installed_name.lower()
-            if "ministral" in lowered and "8b" in lowered:
-                return installed_name
+            for installed_name in installed:
+                lowered = installed_name.lower()
+                if "ministral-3" in lowered and "8b" in lowered:
+                    return installed_name
+            for installed_name in installed:
+                lowered = installed_name.lower()
+                if "ministral" in lowered and "8b" in lowered:
+                    return installed_name
 
         return None
 

iints/analysis/run_quality.py

@@ -1,13 +1,28 @@
 from __future__ import annotations
 
+import json
+import os
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 import pandas as pd
 
+from iints.ai.backends.ollama import DEFAULT_MINISTRAL_MODEL, OllamaBackend
 from iints.analysis.safety_visualizer import write_safety_visualizer
 from iints.data.realism_dashboard import write_realism_dashboard
 from iints.data.realism_validator import validate_realism_dataset, write_realism_report
+from iints.governance import RESEARCH_ONLY_NOTICE, guard_ai_output
+
+
+CORE_RESULT_COLUMNS = (
+    "time_minutes",
+    "glucose_actual_mgdl",
+    "delivered_insulin_units",
+)
+
+LOCAL_AI_REVIEW_ENV = "IINTS_LOCAL_AI_REVIEW"
+LOCAL_AI_REVIEW_MODEL_ENV = "IINTS_LOCAL_AI_MODEL"
+LOCAL_AI_REVIEW_TIMEOUT_ENV = "IINTS_LOCAL_AI_REVIEW_TIMEOUT_SECONDS"
 
 
 def _series_or_default(df: pd.DataFrame, column: str, default: float = 0.0) -> pd.Series:
@@ -53,6 +68,7 @@ def _write_run_quality_markdown(
     realism_report: Any,
     selected_reference: str | None,
     reference_selection: str | None,
+    quality_summary: Dict[str, Any],
 ) -> Path:
     failed = [check for check in realism_report.checks if check.status == "failed"]
     warnings = [check for check in realism_report.checks if check.status == "warning"]
@@ -65,6 +81,8 @@ def _write_run_quality_markdown(
         "",
         f"- Verdict: `{realism_report.verdict}`",
         f"- Realism score: `{realism_report.realism_score:.2f}`",
+        f"- Result quality grade: `{quality_summary['grade']}`",
+        f"- Result quality score: `{quality_summary['score']:.1f}/100`",
         f"- Reference selection: `{reference_selection}`",
         f"- Applied reference: `{selected_reference or 'none'}`",
         f"- Mean glucose: `{realism_report.metrics.get('mean_glucose_mgdl')} mg/dL`",
@@ -77,6 +95,11 @@ def _write_run_quality_markdown(
         realism_report.summary,
         "",
     ]
+    if quality_summary["review_reasons"]:
+        lines.extend(["## Result Quality Gate", ""])
+        for reason in quality_summary["review_reasons"]:
+            lines.append(f"- {reason}")
+        lines.append("")
     if failed or warnings:
         lines.extend(["## Review Items", ""])
         for check in failed + warnings:
@@ -106,6 +129,415 @@ def _write_run_quality_markdown(
     return output_path
 
 
+def _count_safety_interventions(results_df: pd.DataFrame, safety_report: Optional[Dict[str, Any]]) -> int:
+    if safety_report:
+        for key in (
+            "bolus_interventions_count",
+            "interventions_count",
+            "safety_interventions_count",
+            "total_overrides",
+        ):
+            if key in safety_report:
+                try:
+                    return int(safety_report[key])
+                except (TypeError, ValueError):
+                    pass
+    if "safety_triggered" not in results_df.columns:
+        return 0
+    return int(results_df["safety_triggered"].fillna(False).astype(bool).sum())
+
+
+def _routine_safety_adjustment_mask(results_df: pd.DataFrame) -> pd.Series:
+    """Identify routine deterministic dose shaping, not hard safety failures."""
+
+    if "safety_reason" not in results_df.columns:
+        return pd.Series([False] * len(results_df), index=results_df.index)
+    reasons = results_df["safety_reason"].fillna("").astype(str)
+    return (
+        reasons.str.startswith("PD_STACKING_PREVENTION")
+        | reasons.str.startswith("PD_CLEARANCE_LIMIT")
+        | reasons.str.startswith("WARNING: Hyperglycemia detected")
+    )
+
+
+def _count_routine_safety_adjustments(results_df: pd.DataFrame) -> int:
+    if "safety_triggered" not in results_df.columns:
+        return 0
+    triggered = results_df["safety_triggered"].fillna(False).astype(bool)
+    return int((triggered & _routine_safety_adjustment_mask(results_df)).sum())
+
+
+def _count_material_safety_interventions(results_df: pd.DataFrame) -> int:
+    if "safety_triggered" not in results_df.columns:
+        return 0
+    triggered = results_df["safety_triggered"].fillna(False).astype(bool)
+    routine = _routine_safety_adjustment_mask(results_df)
+    return int((triggered & ~routine).sum())
+
+
+def build_result_quality_summary(
+    results_df: pd.DataFrame,
+    *,
+    realism_report: Any,
+    safety_report: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Build a deterministic reviewer-facing quality gate for one run."""
+    review_reasons: list[str] = []
+    score = float(realism_report.realism_score) * 100.0
+
+    missing_columns = [column for column in CORE_RESULT_COLUMNS if column not in results_df.columns]
+    if missing_columns:
+        review_reasons.append(f"Missing core result columns: {', '.join(missing_columns)}.")
+        score -= 25.0
+
+    glucose = pd.to_numeric(results_df.get("glucose_actual_mgdl", pd.Series(dtype=float)), errors="coerce")
+    nan_glucose_rows = int(glucose.isna().sum())
+    if nan_glucose_rows:
+        review_reasons.append(f"{nan_glucose_rows} glucose row(s) are NaN or non-numeric.")
+        score -= min(20.0, nan_glucose_rows * 2.0)
+
+    timestamps = pd.to_numeric(results_df.get("time_minutes", pd.Series(dtype=float)), errors="coerce")
+    duplicate_timestamp_rows = int(timestamps.duplicated().sum()) if not timestamps.empty else 0
+    if duplicate_timestamp_rows:
+        review_reasons.append(f"{duplicate_timestamp_rows} duplicate timestamp row(s) detected.")
+        score -= min(15.0, duplicate_timestamp_rows * 1.5)
+
+    terminated_early = bool((safety_report or {}).get("terminated_early", False))
+    if terminated_early:
+        review_reasons.append("Simulation terminated early.")
+        score -= 35.0
+
+    intervention_count = _count_safety_interventions(results_df, safety_report)
+    routine_adjustment_count = _count_routine_safety_adjustments(results_df)
+    material_intervention_count = _count_material_safety_interventions(results_df)
+    if material_intervention_count:
+        review_reasons.append(f"{material_intervention_count} material safety intervention(s) occurred.")
+        score -= min(20.0, material_intervention_count * 0.75)
+    if routine_adjustment_count:
+        review_reasons.append(
+            f"{routine_adjustment_count} routine pharmacodynamic dose-shaping adjustment(s) occurred."
+        )
+        score -= min(4.0, routine_adjustment_count * 0.02)
+
+    fail_soft_count = int((safety_report or {}).get("input_validator_fail_soft_count", 0) or 0)
+    if fail_soft_count:
+        review_reasons.append(f"{fail_soft_count} input-validator fail-soft event(s) occurred.")
+        score -= min(20.0, fail_soft_count * 2.0)
+
+    if realism_report.verdict == "likely_unrealistic":
+        review_reasons.append("Realism verdict is likely_unrealistic.")
+        score -= 30.0
+    elif realism_report.verdict == "needs_review":
+        review_reasons.append("Realism verdict needs_review.")
+        score -= 10.0
+
+    score = max(0.0, min(100.0, score))
+    if terminated_early or missing_columns or realism_report.verdict == "likely_unrealistic":
+        grade = "do_not_use"
+    elif score < 75.0 or realism_report.verdict == "needs_review" or fail_soft_count:
+        grade = "review_before_use"
+    else:
+        grade = "research_ready"
+
+    return {
+        "grade": grade,
+        "score": round(score, 3),
+        "review_reasons": review_reasons,
+        "row_count": int(len(results_df)),
+        "missing_columns": missing_columns,
+        "nan_glucose_rows": nan_glucose_rows,
+        "duplicate_timestamp_rows": duplicate_timestamp_rows,
+        "safety_intervention_count": intervention_count,
+        "material_safety_intervention_count": material_intervention_count,
+        "routine_dose_shaping_count": routine_adjustment_count,
+        "input_validator_fail_soft_count": fail_soft_count,
+        "terminated_early": terminated_early,
+        "realism_verdict": realism_report.verdict,
+        "realism_score": float(realism_report.realism_score),
+    }
+
+
+def _json_safe(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, Path):
+        return str(value)
+    if hasattr(value, "item"):
+        try:
+            return _json_safe(value.item())
+        except Exception:
+            pass
+    try:
+        if pd.isna(value):
+            return None
+    except (TypeError, ValueError):
+        pass
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    return str(value)
+
+
+def _resolve_local_ai_review_mode(local_ai_review: bool | str | None) -> str:
+    raw_value: bool | str | None = local_ai_review
+    if raw_value is None:
+        raw_value = os.getenv(LOCAL_AI_REVIEW_ENV, "auto")
+    if isinstance(raw_value, bool):
+        return "auto" if raw_value else "off"
+    normalized = str(raw_value).strip().lower()
+    if normalized in {"1", "true", "yes", "on", "enabled"}:
+        return "auto"
+    if normalized in {"0", "false", "no", "off", "disabled", "skip"}:
+        return "off"
+    if normalized in {"required", "force", "strict"}:
+        return "required"
+    if normalized == "auto":
+        return "auto"
+    return "auto"
+
+
+def _local_ai_timeout_seconds(default: float) -> float:
+    raw_value = os.getenv(LOCAL_AI_REVIEW_TIMEOUT_ENV)
+    if not raw_value:
+        return default
+    try:
+        return max(1.0, float(raw_value))
+    except ValueError:
+        return default
+
+
+def _sample_results_rows(results_df: pd.DataFrame, *, max_rows: int = 72) -> list[dict[str, Any]]:
+    preferred_columns = [
+        "time_minutes",
+        "glucose_actual_mgdl",
+        "glucose_sensor_mgdl",
+        "carb_intake_grams",
+        "delivered_insulin_units",
+        "algo_recommended_insulin_units",
+        "active_insulin_units",
+        "safety_triggered",
+        "safety_reason",
+    ]
+    columns = [column for column in preferred_columns if column in results_df.columns]
+    if not columns or results_df.empty:
+        return []
+    step = max(1, len(results_df) // max_rows)
+    sampled = results_df.loc[:, columns].iloc[::step].head(max_rows)
+    return _json_safe(sampled.to_dict(orient="records"))
+
+
+def _scalar_safety_summary(safety_report: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if not safety_report:
+        return {}
+    summary: Dict[str, Any] = {}
+    for key, value in safety_report.items():
+        if isinstance(value, (str, int, float, bool)) or value is None:
+            summary[key] = _json_safe(value)
+    return summary
+
+
+def _build_local_ai_review_payload(
+    results_df: pd.DataFrame,
+    *,
+    run_label: str,
+    realism_report: Any,
+    selected_reference: str | None,
+    reference_selection: str | None,
+    quality_summary: Dict[str, Any],
+    safety_report: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    return {
+        "run_label": run_label,
+        "research_only": True,
+        "medical_device": False,
+        "instruction": (
+            "Use the deterministic run_quality grade as source of truth. "
+            "The local AI verifier may explain risks and suggest research checks, "
+            "but must not provide treatment or dosing advice."
+        ),
+        "realism": {
+            "verdict": realism_report.verdict,
+            "score": float(realism_report.realism_score),
+            "summary": realism_report.summary,
+            "metrics": _json_safe(realism_report.metrics),
+            "reference": selected_reference,
+            "reference_selection": reference_selection,
+            "checks": [
+                {
+                    "title": check.title,
+                    "status": check.status,
+                    "detail": check.detail,
+                }
+                for check in realism_report.checks
+                if check.status in {"failed", "warning"}
+            ],
+        },
+        "deterministic_quality_gate": _json_safe(quality_summary),
+        "safety": _scalar_safety_summary(safety_report),
+        "sampled_results": _sample_results_rows(results_df),
+    }
+
+
+def _write_local_ai_metadata(
+    metadata_path: Path,
+    *,
+    status: str,
+    model: str,
+    reason: str | None = None,
+    markdown_path: Path | None = None,
+    policy_violations: tuple[str, ...] = (),
+    policy_warnings: tuple[str, ...] = (),
+    policy_action: str = "allow",
+) -> Dict[str, Any]:
+    metadata = {
+        "status": status,
+        "model": model,
+        "reason": reason,
+        "markdown": str(markdown_path) if markdown_path else None,
+        "research_only": True,
+        "medical_device": False,
+        "policy_violations": list(policy_violations),
+        "policy_warnings": list(policy_warnings),
+        "policy_action": policy_action,
+    }
+    metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    metadata_path.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+    return metadata
+
+
+def _write_local_ai_run_verification(
+    results_df: pd.DataFrame,
+    output_path: Path,
+    *,
+    run_label: str,
+    realism_report: Any,
+    selected_reference: str | None,
+    reference_selection: str | None,
+    quality_summary: Dict[str, Any],
+    safety_report: Optional[Dict[str, Any]],
+    local_ai_review: bool | str | None,
+    local_ai_model: str,
+    local_ai_timeout_seconds: float,
+    ollama_host: str | None,
+) -> Dict[str, Any]:
+    ai_dir = output_path / "ai"
+    markdown_path = ai_dir / "local_run_verification.md"
+    metadata_path = ai_dir / "local_run_verification.json"
+    mode = _resolve_local_ai_review_mode(local_ai_review)
+
+    if mode == "off":
+        metadata = _write_local_ai_metadata(
+            metadata_path,
+            status="skipped",
+            model=local_ai_model,
+            reason=f"disabled via {LOCAL_AI_REVIEW_ENV}",
+        )
+        return {
+            "local_ai_review_status": metadata["status"],
+            "local_ai_review_json": str(metadata_path),
+        }
+
+    if mode == "auto" and os.getenv("CI", "").strip().lower() in {"1", "true", "yes"}:
+        metadata = _write_local_ai_metadata(
+            metadata_path,
+            status="skipped",
+            model=local_ai_model,
+            reason="disabled during CI; set IINTS_LOCAL_AI_REVIEW=required to force it",
+        )
+        return {
+            "local_ai_review_status": metadata["status"],
+            "local_ai_review_json": str(metadata_path),
+        }
+
+    try:
+        backend = OllamaBackend(
+            model_name=local_ai_model,
+            base_url=ollama_host,
+            timeout_seconds=_local_ai_timeout_seconds(local_ai_timeout_seconds),
+            temperature=0.0,
+            top_p=0.7,
+            num_predict=900,
+            num_ctx=8192,
+        )
+        if not backend.available():
+            reason = (
+                f"local Ollama is not reachable at {backend.base_url}; "
+                "start Ollama to enable automatic local AI verification"
+            )
+            if mode == "required":
+                raise RuntimeError(reason)
+            metadata = _write_local_ai_metadata(
+                metadata_path,
+                status="skipped",
+                model=local_ai_model,
+                reason=reason,
+            )
+            return {
+                "local_ai_review_status": metadata["status"],
+                "local_ai_review_json": str(metadata_path),
+            }
+        resolved_model = backend.ensure_model_ready()
+        payload = _build_local_ai_review_payload(
+            results_df,
+            run_label=run_label,
+            realism_report=realism_report,
+            selected_reference=selected_reference,
+            reference_selection=reference_selection,
+            quality_summary=quality_summary,
+            safety_report=safety_report,
+        )
+        system_prompt = (
+            "You are the local IINTS-AF run verifier. You review simulation output for "
+            "research and education only. You are not a medical device and must not give "
+            "insulin, glucagon, diagnosis, or treatment advice. Treat the deterministic "
+            "quality gate as authoritative; your role is to explain what looks trustworthy, "
+            "what needs review, and what next checks would improve the research result. "
+            f"Boundary: {RESEARCH_ONLY_NOTICE}"
+        )
+        user_prompt = (
+            "Review this bounded IINTS run summary and return concise Markdown with exactly "
+            "these sections: ## Verdict, ## What Looks Trustworthy, ## What Needs Review, "
+            "## Next Checks, ## Research-Only Note. Keep it concrete and cite the provided "
+            "metrics. Do not invent clinical validation.\n\n"
+            f"```json\n{json.dumps(_json_safe(payload), indent=2)}\n```"
+        )
+        response_text = backend.complete(system_prompt=system_prompt, user_prompt=user_prompt).strip()
+        if not response_text:
+            raise RuntimeError("local AI verifier returned an empty response")
+        guarded = guard_ai_output(response_text, source="run_quality_local_ai")
+        ai_dir.mkdir(parents=True, exist_ok=True)
+        markdown_path.write_text(guarded.text + "\n", encoding="utf-8")
+        metadata = _write_local_ai_metadata(
+            metadata_path,
+            status="completed" if guarded.allowed else "blocked_policy",
+            model=resolved_model,
+            markdown_path=markdown_path,
+            policy_violations=guarded.violations,
+            policy_warnings=guarded.warnings,
+            policy_action=guarded.action,
+        )
+        return {
+            "local_ai_review_status": metadata["status"],
+            "local_ai_review_md": str(markdown_path),
+            "local_ai_review_json": str(metadata_path),
+            "local_ai_review_model": resolved_model,
+        }
+    except Exception as exc:
+        if mode == "required":
+            raise
+        metadata = _write_local_ai_metadata(
+            metadata_path,
+            status="failed",
+            model=local_ai_model,
+            reason=str(exc),
+        )
+        return {
+            "local_ai_review_status": metadata["status"],
+            "local_ai_review_json": str(metadata_path),
+        }
+
+
 def write_run_quality_artifacts(
     results_df: pd.DataFrame,
     output_dir: str | Path,
@@ -113,6 +545,10 @@ def write_run_quality_artifacts(
     run_label: Optional[str] = None,
     safety_report: Optional[Dict[str, Any]] = None,
     realism_reference: Optional[str] = "auto",
+    local_ai_review: bool | str | None = None,
+    local_ai_model: str | None = None,
+    local_ai_timeout_seconds: float = 90.0,
+    ollama_host: str | None = None,
 ) -> Dict[str, Any]:
     """Write reviewer-facing quality artifacts for one run.
 
@@ -132,7 +568,14 @@ def write_run_quality_artifacts(
         realism_json = output_path / "realism_report.json"
         realism_html = output_path / "realism_dashboard.html"
         realism_markdown = output_path / "run_quality_review.md"
+        quality_json = output_path / "run_quality_summary.json"
         write_realism_report(realism_report, realism_json)
+        quality_summary = build_result_quality_summary(
+            results_df,
+            realism_report=realism_report,
+            safety_report=safety_report,
+        )
+        quality_json.write_text(json.dumps(quality_summary, indent=2), encoding="utf-8")
         write_realism_dashboard(
             realism_report,
             realism_frame,
@@ -146,6 +589,7 @@ def write_run_quality_artifacts(
             realism_report=realism_report,
             selected_reference=selected_reference,
             reference_selection=realism_reference,
+            quality_summary=quality_summary,
         )
         realism_summary = {
             "verdict": realism_report.verdict,
@@ -153,17 +597,48 @@ def write_run_quality_artifacts(
             "summary": realism_report.summary,
             "reference": selected_reference,
             "reference_selection": realism_reference,
+            "quality_grade": quality_summary["grade"],
+            "quality_score": quality_summary["score"],
         }
         if safety_report is not None:
             safety_report["realism_review"] = realism_summary
+            safety_report["run_quality"] = quality_summary
         outputs.update(
             {
                 "realism_report_json": str(realism_json),
                 "realism_dashboard_html": str(realism_html),
                 "run_quality_review_md": str(realism_markdown),
+                "run_quality_summary_json": str(quality_json),
                 "realism_review": realism_summary,
+                "run_quality": quality_summary,
             }
         )
+        local_ai_outputs = _write_local_ai_run_verification(
+            results_df,
+            output_path,
+            run_label=label,
+            realism_report=realism_report,
+            selected_reference=selected_reference,
+            reference_selection=realism_reference,
+            quality_summary=quality_summary,
+            safety_report=safety_report,
+            local_ai_review=local_ai_review,
+            local_ai_model=local_ai_model
+            or os.getenv(LOCAL_AI_REVIEW_MODEL_ENV)
+            or DEFAULT_MINISTRAL_MODEL,
+            local_ai_timeout_seconds=local_ai_timeout_seconds,
+            ollama_host=ollama_host,
+        )
+        outputs.update(local_ai_outputs)
+        if local_ai_outputs:
+            quality_summary["local_ai_review_status"] = local_ai_outputs.get("local_ai_review_status")
+            if local_ai_outputs.get("local_ai_review_md"):
+                quality_summary["local_ai_review_md"] = local_ai_outputs["local_ai_review_md"]
+            if local_ai_outputs.get("local_ai_review_json"):
+                quality_summary["local_ai_review_json"] = local_ai_outputs["local_ai_review_json"]
+            quality_json.write_text(json.dumps(quality_summary, indent=2), encoding="utf-8")
+            if safety_report is not None:
+                safety_report["run_quality"] = quality_summary
     except Exception as exc:
         outputs["realism_warning"] = str(exc)
 

iints/cli/cli.py

@@ -488,6 +488,27 @@ def _maybe_prepare_ai_artifacts(output_dir: Path, console: Console) -> None:
         console.print(f"[yellow]AI-ready payload export skipped:[/yellow] {exc}")
 
 
+def _print_run_quality_review(console: Console, quality_outputs: Dict[str, Any]) -> None:
+    realism_review = quality_outputs.get("realism_review")
+    if not realism_review:
+        return
+    verdict = realism_review.get("verdict")
+    realism_score = float(realism_review.get("realism_score", 0.0))
+    quality_grade = realism_review.get("quality_grade", "unknown")
+    quality_score = float(realism_review.get("quality_score", 0.0))
+    console.print(
+        "[green]Run quality:[/green] "
+        f"{quality_grade} ({quality_score:.1f}/100); "
+        f"realism {verdict} ({realism_score:.2f})"
+    )
+    ai_status = quality_outputs.get("local_ai_review_status")
+    if ai_status == "completed":
+        console.print(f"[green]Local AI verifier:[/green] {quality_outputs.get('local_ai_review_md')}")
+    elif ai_status in {"failed", "skipped"}:
+        ai_json = quality_outputs.get("local_ai_review_json")
+        console.print(f"[yellow]Local AI verifier:[/yellow] {ai_status} ({ai_json})")
+
+
 def _get_preset(name: str) -> Dict[str, Any]:
     presets = _load_presets()
     for preset in presets:
@@ -4786,12 +4807,7 @@ def presets_run(
         run_label=run_id,
         safety_report=safety_report,
     )
-    if quality_outputs.get("realism_review"):
-        realism_review = quality_outputs["realism_review"]
-        console.print(
-            "[green]Realism review:[/green] "
-            f"{realism_review.get('verdict')} (score {float(realism_review.get('realism_score', 0.0)):.2f})"
-        )
+    _print_run_quality_review(console, quality_outputs)
     console.print(f"Safety visualizer: {quality_outputs.get('safety_visualizer_html')}")
 
     manifest_files = {
@@ -4811,6 +4827,8 @@ def presets_run(
         "realism_dashboard": "realism_dashboard_html",
         "safety_visualizer": "safety_visualizer_html",
         "safety_visualizer_json": "safety_visualizer_json",
+        "local_ai_review": "local_ai_review_md",
+        "local_ai_review_json": "local_ai_review_json",
     }.items():
         output_value = quality_outputs.get(output_key)
         if output_value:
@@ -5536,6 +5554,8 @@ def run(
             "realism_dashboard": "realism_dashboard_html",
             "safety_visualizer": "safety_visualizer_html",
             "safety_visualizer_json": "safety_visualizer_json",
+            "local_ai_review": "local_ai_review_md",
+            "local_ai_review_json": "local_ai_review_json",
         }.items():
             output_value = quality_outputs.get(output_key)
             if output_value:
@@ -5548,12 +5568,7 @@ def run(
     console.print(f"Using compute device: [blue]{device}[/blue]")
     if baseline_paths is not None:
         console.print(f"Baseline comparison saved to: {baseline_paths}")
-    if quality_outputs.get("realism_review"):
-        realism_review = quality_outputs["realism_review"]
-        console.print(
-            "[green]Realism review:[/green] "
-            f"{realism_review.get('verdict')} (score {float(realism_review.get('realism_score', 0.0)):.2f})"
-        )
+    _print_run_quality_review(console, quality_outputs)
     if quality_outputs.get("safety_visualizer_html"):
         console.print(f"Safety visualizer: {quality_outputs.get('safety_visualizer_html')}")
     console.print(f"Run metadata: {run_metadata_path}")
@@ -10955,9 +10970,12 @@ def medtronic_live_cmd(
             start=1,
         ):
             if not timeline.empty:
+                if merged.empty:
+                    merged = timeline.copy()
+                else:
+                    merged = pd.concat([merged, timeline], ignore_index=True)
                 merged = (
-                    pd.concat([merged, timeline], ignore_index=True)
-                    .sort_values("timestamp_dt")
+                    merged.sort_values("timestamp_dt")
                     .drop_duplicates("timestamp_dt", keep="last")
                     .reset_index(drop=True)
                 )