invarlock 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

invarlock/cli/commands/{certify.py → evaluate.py}

@@ -1,15 +1,15 @@
 """
-InvarLock CLI Certify Command
+InvarLock CLI Evaluate Command
 =========================
 
-Hero path: Compare & Certify (BYOE). Provide baseline (`--baseline`) and
+Hero path: Compare & Evaluate (BYOE). Provide baseline (`--baseline`) and
 subject (`--subject`) checkpoints and InvarLock will run paired windows and emit a
-certificate. Optionally, pass `--edit-config` to run the built‑in quant_rtn demo.
+evaluation report. Optionally, pass `--edit-config` to run the built‑in quant_rtn demo.
 
 Steps:
   1) Baseline (no-op edit) on baseline model
   2) Subject (no-op or provided edit config) on subject model with --baseline pairing
-  3) Emit certificate via `invarlock report --format cert`
+  3) Emit evaluation report via `invarlock report --format report`
 """
 
 from __future__ import annotations
@@ -18,6 +18,7 @@ import inspect
 import io
 import json
 import math
+import os
 from collections.abc import Iterator
 from contextlib import contextmanager
 from pathlib import Path
@@ -60,7 +61,7 @@ def _render_banner_lines(title: str, context: str) -> list[str]:
 def _print_header_banner(
     console: Console, *, version: str, profile: str, tier: str, adapter: str
 ) -> None:
-    title = f"INVARLOCK v{version} · Certification Pipeline"
+    title = f"INVARLOCK v{version} · Evaluation Pipeline"
     context = f"Profile: {profile} · Tier: {tier} · Adapter: {adapter}"
     for line in _render_banner_lines(title, context):
         console.print(line)
@@ -128,32 +129,32 @@ def _suppress_child_output(enabled: bool) -> Iterator[io.StringIO | None]:
 
 def _print_quiet_summary(
     *,
-    cert_out: Path,
+    report_out: Path,
     source: str,
     edited: str,
     profile: str,
 ) -> None:
-    cert_path = cert_out / "evaluation.cert.json"
-    console.print(f"INVARLOCK v{INVARLOCK_VERSION} · CERTIFY")
+    report_path = report_out / "evaluation.report.json"
+    console.print(f"INVARLOCK v{INVARLOCK_VERSION} · EVALUATE")
     console.print(f"Baseline: {source} -> Subject: {edited} · Profile: {profile}")
-    if not cert_path.exists():
-        console.print(f"Output: {cert_out}")
+    if not report_path.exists():
+        console.print(f"Output: {report_out}")
         return
     try:
-        with cert_path.open("r", encoding="utf-8") as fh:
-            certificate = json.load(fh)
+        with report_path.open("r", encoding="utf-8") as fh:
+            evaluation_report = json.load(fh)
     except Exception:
-        console.print(f"Output: {cert_path}")
+        console.print(f"Output: {report_path}")
         return
-    if not isinstance(certificate, dict):
-        console.print(f"Output: {cert_path}")
+    if not isinstance(evaluation_report, dict):
+        console.print(f"Output: {report_path}")
         return
     try:
         from invarlock.reporting.render import (
             compute_console_validation_block as _console_block,
         )
 
-        block = _console_block(certificate)
+        block = _console_block(evaluation_report)
         rows = block.get("rows", [])
         total = len(rows) if isinstance(rows, list) else 0
         passed = (
@@ -165,13 +166,13 @@ def _print_quiet_summary(
         passed = 0
         status = "UNKNOWN"
     pm_ratio = _format_ratio(
-        (certificate.get("primary_metric") or {}).get("ratio_vs_baseline")
+        (evaluation_report.get("primary_metric") or {}).get("ratio_vs_baseline")
     )
     gate_summary = f"{passed}/{total} passed" if total else "N/A"
     console.print(f"Status: {status} · Gates: {gate_summary}")
     if pm_ratio != "N/A":
         console.print(f"Primary metric ratio: {pm_ratio}")
-    console.print(f"Output: {cert_path}")
+    console.print(f"Output: {report_path}")
 
 
 def _latest_run_report(run_root: Path) -> Path | None:
@@ -206,6 +207,23 @@ def _dump_yaml(path: Path, data: dict[str, Any]) -> None:
         yaml.safe_dump(data, fh, sort_keys=False)
 
 
+def _resolve_evaluate_tmp_dir() -> Path:
+    """Return the on-disk scratch directory for `invarlock evaluate`.
+
+    Evaluate generates merged YAML configs for baseline/subject runs so
+    downstream `invarlock run` flows remain traceable. We keep these files
+    under `./tmp/.evaluate` by default to avoid cluttering the working tree.
+    """
+
+    candidate = os.environ.get("INVARLOCK_EVALUATE_TMP_DIR")
+    if candidate:
+        tmp_dir = Path(candidate).expanduser()
+    else:
+        tmp_dir = Path("tmp") / ".evaluate"
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+    return tmp_dir
+
+
 def _normalize_model_id(model_id: str, adapter_name: str) -> str:
     """Normalize model identifiers for adapters.
 
@@ -221,7 +239,7 @@ def _normalize_model_id(model_id: str, adapter_name: str) -> str:
     return mid
 
 
-def certify_command(
+def evaluate_command(
     # Primary names for programmatic/test compatibility
     source: str = typer.Option(
         ..., "--source", "--baseline", help="Baseline model dir or Hub ID"
@@ -258,8 +276,8 @@ def certify_command(
         ),
     ),
     out: str = typer.Option("runs", "--out", help="Base output directory"),
-    cert_out: str = typer.Option(
-        "reports/cert", "--cert-out", help="Certificate output directory"
+    report_out: str = typer.Option(
+        "reports/eval", "--report-out", help="Evaluation report output directory"
     ),
     edit_config: str | None = typer.Option(
         None, "--edit-config", help="Edit preset to apply a demo edit (quant_rtn)"
@@ -290,7 +308,7 @@ def certify_command(
         False, "--no-color", help="Disable ANSI colors (respects NO_COLOR=1)"
     ),
 ):
-    """Certify two checkpoints (baseline vs subject) with pinned windows."""
+    """Evaluate two checkpoints (baseline vs subject) with pinned windows."""
     # Support programmatic calls and Typer-invoked calls uniformly
     try:
         from typer.models import OptionInfo as _TyperOptionInfo
@@ -311,7 +329,7 @@ def certify_command(
     tier = _coerce_option(tier, "balanced")
     preset = _coerce_option(preset)
     out = _coerce_option(out, "runs")
-    cert_out = _coerce_option(cert_out, "reports/cert")
+    report_out = _coerce_option(report_out, "reports/eval")
     edit_config = _coerce_option(edit_config)
     edit_label = _coerce_option(edit_label)
     quiet = _coerce_option(quiet, False)
@@ -410,7 +428,7 @@ def certify_command(
                 "stride": 512,
                 "preview_n": 64,
                 "final_n": 64,
-                "seed": 42,
+                "seed": 43,
             }
         }
     else:
@@ -424,7 +442,7 @@ def certify_command(
             )
             raise typer.Exit(1)
         preset_data = _load_yaml(preset_path)
-        # Do not hard-code device from presets in auto-generated certify configs;
+        # Do not hard-code device from presets in auto-generated evaluate configs;
         # allow device resolution to pick CUDA/MPS/CPU via 'auto' or CLI overrides.
         model_block = preset_data.get("model")
         if isinstance(model_block, dict) and "device" in model_block:
@@ -575,8 +593,7 @@ def certify_command(
     elif not edit_config:
         subject_label = "custom" if norm_src_id != norm_edt_id else "noop"
 
-    tmp_dir = Path(".certify_tmp")
-    tmp_dir.mkdir(parents=True, exist_ok=True)
+    tmp_dir = _resolve_evaluate_tmp_dir()
 
     baseline_report_path: Path
     if baseline_report:
@@ -635,7 +652,7 @@ def certify_command(
         baseline_report_path = baseline_report_path_candidate
         _debug(f"Baseline report: {baseline_report_path}")
 
-    # Edited run: either no-op (Compare & Certify) or provided edit_config (demo edit)
+    # Edited run: either no-op (Compare & Evaluate) or provided edit_config (demo edit)
     _phase(2, 3, "SUBJECT EVALUATION")
     if edit_config:
         edited_yaml = Path(edit_config)
@@ -704,8 +721,6 @@ def certify_command(
             )
 
         # Persist a temporary merged config for traceability
-        tmp_dir = Path(".certify_tmp")
-        tmp_dir.mkdir(parents=True, exist_ok=True)
         edited_merged_yaml = tmp_dir / "edited_merged.yaml"
         _dump_yaml(edited_merged_yaml, merged_edited_cfg)
         _debug(f"Edited config (merged): {edited_merged_yaml}")
@@ -754,7 +769,7 @@ def certify_command(
         )
         edited_yaml = tmp_dir / "edited_noop.yaml"
         _dump_yaml(edited_yaml, edited_cfg)
-        _info("Running edited (no-op, Compare & Certify)", tag="EXEC", emoji="🧪")
+        _info("Running edited (no-op, Compare & Evaluate)", tag="EXEC", emoji="🧪")
         _debug(f"Edited config: {edited_yaml}")
         from .run import run_command as _run
 
@@ -799,28 +814,36 @@ def certify_command(
         raise typer.Exit(1)
     _debug(f"Edited report: {edited_report}")
 
-    _phase(3, 3, "CERTIFICATE GENERATION")
+    _phase(3, 3, "EVALUATION REPORT GENERATION")
 
-    def _emit_certificate() -> None:
-        _info("Emitting certificate", tag="EXEC", emoji="📜")
+    def _emit_evaluation_report() -> None:
+        _info("Emitting evaluation report", tag="EXEC", emoji="📜")
         with _suppress_child_output(verbosity == VERBOSITY_QUIET) as quiet_buffer:
             try:
                 with timed_step(
                     console=console,
                     style=output_style,
                     timings=timings,
-                    key="certificate",
+                    key="evaluation_report",
                     tag="EXEC",
-                    message="Certificate",
+                    message="Evaluation Report",
                     emoji="📜",
                 ):
+                    # Use a wall-clock perf counter here (not the output module's
+                    # test-patched counter) so timing tests remain deterministic.
+                    from time import perf_counter as _wall_perf_counter
+
+                    report_start = _wall_perf_counter()
                     report_kwargs = {
                         "run": str(edited_report),
-                        "format": "cert",
+                        "format": "report",
                         "baseline": str(baseline_report_path),
-                        "output": cert_out,
+                        "output": report_out,
                         "style": output_style.name,
                         "no_color": no_color,
+                        "summary_baseline_seconds": float(timings.get("baseline", 0.0)),
+                        "summary_subject_seconds": float(timings.get("subject", 0.0)),
+                        "summary_report_start": float(report_start),
                     }
                     try:
                         sig = inspect.signature(_report)
@@ -890,7 +913,7 @@ def certify_command(
             else None
         ) or "unknown"
 
-        # Enforce only when a primary_metric block is present; allow degraded-but-flagged metrics to emit certificates, but fail the task.
+        # Enforce only when a primary_metric block is present; allow degraded-but-flagged metrics to emit evaluation reports, but fail the task.
         has_metric_block = isinstance(pm, dict) and bool(pm)
         if has_metric_block:
             degraded = bool(pm.get("invalid") or pm.get("degraded"))
@@ -906,7 +929,7 @@ def certify_command(
                 print_event(
                     console,
                     "WARN",
-                    "Primary metric degraded or non-finite; emitting certificate and marking task degraded. Primary metric computation failed.",
+                    "Primary metric degraded or non-finite; emitting evaluation report and marking task degraded. Primary metric computation failed.",
                     style=output_style,
                     emoji="⚠️",
                 )
@@ -919,8 +942,8 @@ def certify_command(
                 metrics["primary_metric"] = pm
                 edited_payload.setdefault("metrics", {}).update(metrics)
 
-                # Emit the certificate for inspection, then exit with a CI-visible error.
-                _emit_certificate()
+                # Emit the evaluation report for inspection, then exit with a CI-visible error.
+                _emit_evaluation_report()
                 err = MetricsError(
                     code="E111",
                     message=f"Primary metric degraded or non-finite ({degraded_reason}).",
@@ -933,7 +956,7 @@ def certify_command(
                 )
                 raise typer.Exit(_resolve_exit_code(err, profile=profile))
 
-    _emit_certificate()
+    _emit_evaluation_report()
     if timing:
         if total_start is not None:
             timings["total"] = max(0.0, float(perf_counter() - total_start))
@@ -941,7 +964,7 @@ def certify_command(
             timings["total"] = (
                 float(timings.get("baseline", 0.0))
                 + float(timings.get("subject", 0.0))
-                + float(timings.get("certificate", 0.0))
+                + float(timings.get("evaluation_report", 0.0))
             )
         print_timing_summary(
             console,
@@ -950,13 +973,13 @@ def certify_command(
             order=[
                 ("Baseline", "baseline"),
                 ("Subject", "subject"),
-                ("Certificate", "certificate"),
+                ("Evaluation Report", "evaluation_report"),
                 ("Total", "total"),
             ],
         )
     if verbosity == VERBOSITY_QUIET:
         _print_quiet_summary(
-            cert_out=Path(cert_out),
+            report_out=Path(report_out),
             source=src_id,
             edited=edt_id,
             profile=profile,

invarlock/cli/commands/explain_gates.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 
 import json
+import math
 from pathlib import Path
 
 import typer
 from rich.console import Console
 
 from invarlock.core.auto_tuning import get_tier_policies
-from invarlock.reporting.certificate import make_certificate
+from invarlock.reporting.report_builder import (
+    PM_DRIFT_BAND_DEFAULT,
+    make_report,
+)
 
 console = Console()
 
@@ -18,9 +22,9 @@ def explain_gates_command(
         ..., "--baseline", help="Path to baseline report.json"
     ),
 ) -> None:
-    """Explain certificate gates for a report vs baseline.
+    """Explain evaluation report gates for a report vs baseline.
 
-    Loads the reports, builds a certificate, and prints gate thresholds,
+    Loads the reports, builds an evaluation report, and prints gate thresholds,
     observed statistics, and pass/fail reasons in a compact, readable form.
     """
     report_path = Path(report)
@@ -36,22 +40,22 @@ def explain_gates_command(
         console.print(f"[red]Failed to load inputs: {exc}[/red]")
         raise typer.Exit(1) from exc
 
-    cert = make_certificate(report_data, baseline_data)
+    evaluation_report = make_report(report_data, baseline_data)
     validation = (
-        cert.get("validation", {}) if isinstance(cert.get("validation"), dict) else {}
+        evaluation_report.get("validation", {})
+        if isinstance(evaluation_report.get("validation"), dict)
+        else {}
     )
 
     # Extract tier + metric policy (floors/hysteresis)
-    tier = str((cert.get("auto", {}) or {}).get("tier", "balanced")).lower()
-    tier_thresholds = {
-        "conservative": 1.05,
-        "balanced": 1.10,
-        "aggressive": 1.20,
-        "none": 1.10,
-    }
+    tier = str(
+        (evaluation_report.get("auto", {}) or {}).get("tier", "balanced")
+    ).lower()
+    tier_policies = get_tier_policies()
+    tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
     resolved_policy = (
-        cert.get("resolved_policy", {})
-        if isinstance(cert.get("resolved_policy"), dict)
+        evaluation_report.get("resolved_policy", {})
+        if isinstance(evaluation_report.get("resolved_policy"), dict)
         else {}
     )
     metrics_policy = (
@@ -60,8 +64,6 @@ def explain_gates_command(
         else {}
     )
     if not metrics_policy:
-        tier_policies = get_tier_policies()
-        tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
         metrics_policy = (
             tier_defaults.get("metrics", {}) if isinstance(tier_defaults, dict) else {}
         )
@@ -75,15 +77,37 @@ def explain_gates_command(
     hysteresis_ratio = float(pm_policy.get("hysteresis_ratio", 0.0))
     min_tokens = int(pm_policy.get("min_tokens", 0))
     try:
-        limit_base = float(
-            pm_policy.get("ratio_limit_base", tier_thresholds.get(tier, 1.10))
-            or tier_thresholds.get(tier, 1.10)
-        )
+        limit_base = float(pm_policy.get("ratio_limit_base"))
     except Exception:
-        limit_base = tier_thresholds.get(tier, 1.10)
-    limit_with_hyst = limit_base + max(0.0, hysteresis_ratio)
+        limit_base = None
+    if limit_base is None or not isinstance(limit_base, int | float):
+        limit_base = None
+    elif not float("-inf") < float(limit_base) < float("inf"):
+        limit_base = None
+    if limit_base is None:
+        try:
+            fallback = (
+                tier_defaults.get("metrics", {})
+                if isinstance(tier_defaults, dict)
+                else {}
+            )
+            fallback_pm = (
+                fallback.get("pm_ratio", {}) if isinstance(fallback, dict) else {}
+            )
+            limit_base = float(fallback_pm.get("ratio_limit_base"))
+        except Exception:
+            limit_base = None
+    limit_with_hyst = (
+        float(limit_base) + max(0.0, hysteresis_ratio)
+        if isinstance(limit_base, int | float)
+        else None
+    )
     tokens_ok = True
-    telem = cert.get("telemetry", {}) if isinstance(cert.get("telemetry"), dict) else {}
+    telem = (
+        evaluation_report.get("telemetry", {})
+        if isinstance(evaluation_report.get("telemetry"), dict)
+        else {}
+    )
     try:
         total_tokens = int(telem.get("preview_total_tokens", 0)) + int(
             telem.get("final_total_tokens", 0)
@@ -95,8 +119,8 @@ def explain_gates_command(
     # Primary-metric ratio gate explanation (ppl-like kinds shown as ratios)
     ratio = None
     ratio_ci = None
-    if isinstance(cert.get("primary_metric"), dict):
-        pm = cert.get("primary_metric", {})
+    if isinstance(evaluation_report.get("primary_metric"), dict):
+        pm = evaluation_report.get("primary_metric", {})
         ratio = pm.get("ratio_vs_baseline")
         ratio_ci = pm.get("display_ci")
     hysteresis_applied = bool(validation.get("hysteresis_applied"))
@@ -110,21 +134,26 @@ def explain_gates_command(
             )
         else:
             console.print(f"  observed: {ratio:.3f}x")
-    console.print(
-        f"  threshold: ≤ {limit_base:.2f}x{(f' (+hysteresis {hysteresis_ratio:.3f})' if hysteresis_ratio else '')}"
-    )
+    if isinstance(limit_base, int | float):
+        hyst_suffix = (
+            f" (+hysteresis {hysteresis_ratio:.3f})" if hysteresis_ratio else ""
+        )
+        console.print(f"  threshold: ≤ {float(limit_base):.2f}x{hyst_suffix}")
+    else:
+        console.print("  threshold: unavailable")
     console.print(
         f"  tokens: {'ok' if tokens_ok else 'below floor'} (token floors: min_tokens={min_tokens or 0}, total={int(telem.get('preview_total_tokens', 0)) + int(telem.get('final_total_tokens', 0)) if telem else 0})"
     )
     if hysteresis_applied:
-        console.print(
-            f"  note: hysteresis applied → effective threshold = {limit_with_hyst:.3f}x"
-        )
+        if isinstance(limit_with_hyst, int | float):
+            console.print(
+                f"  note: hysteresis applied → effective threshold = {float(limit_with_hyst):.3f}x"
+            )
 
     # Tail gate explanation (warn/fail; based on per-window Δlog-loss vs baseline)
     pm_tail = (
-        cert.get("primary_metric_tail", {})
-        if isinstance(cert.get("primary_metric_tail"), dict)
+        evaluation_report.get("primary_metric_tail", {})
+        if isinstance(evaluation_report.get("primary_metric_tail"), dict)
         else {}
     )
     if pm_tail:
@@ -191,11 +220,18 @@ def explain_gates_command(
     except Exception:
         pass
 
-    # Drift gate explanation
+    # Drift gate explanation (ppl-like kinds only)
     drift = None
-    drift_ci = None
-    if isinstance(cert.get("primary_metric"), dict):
-        pm = cert.get("primary_metric", {})
+    drift_status = (
+        "PASS" if bool(validation.get("preview_final_drift_acceptable")) else "FAIL"
+    )
+    pm = (
+        evaluation_report.get("primary_metric", {})
+        if isinstance(evaluation_report.get("primary_metric"), dict)
+        else {}
+    )
+    kind = str(pm.get("kind", "") or "").lower()
+    if kind.startswith("ppl"):
         preview = pm.get("preview")
         final = pm.get("final")
         if isinstance(preview, int | float) and isinstance(final, int | float):
@@ -204,24 +240,31 @@ def explain_gates_command(
                     drift = float(final) / float(preview)
             except Exception:
                 drift = None
-    drift_status = (
-        "PASS" if bool(validation.get("preview_final_drift_acceptable")) else "FAIL"
-    )
-    console.print("\n[bold]Gate: Drift (final/preview)[/bold]")
-    if isinstance(drift, int | float):
-        if isinstance(drift_ci, tuple | list) and len(drift_ci) == 2:
-            console.print(
-                f"  observed: {drift:.3f} (CI {drift_ci[0]:.3f}-{drift_ci[1]:.3f})"
-            )
-        else:
+
+        console.print("\n[bold]Gate: Drift (final/preview)[/bold]")
+        if isinstance(drift, int | float):
             console.print(f"  observed: {drift:.3f}")
-    console.print("  threshold: 0.95-1.05")
-    console.print(f"  status: {drift_status}")
+        drift_band = (
+            pm.get("drift_band") if isinstance(pm.get("drift_band"), dict) else {}
+        )
+        drift_min = drift_band.get("min")
+        drift_max = drift_band.get("max")
+        if not (
+            isinstance(drift_min, int | float)
+            and isinstance(drift_max, int | float)
+            and math.isfinite(float(drift_min))
+            and math.isfinite(float(drift_max))
+            and float(drift_min) > 0.0
+            and float(drift_min) < float(drift_max)
+        ):
+            drift_min, drift_max = PM_DRIFT_BAND_DEFAULT
+        console.print(f"  threshold: {float(drift_min):.3f}-{float(drift_max):.3f}")
+        console.print(f"  status: {drift_status}")
 
     # Guard Overhead explanation (if present)
     overhead = (
-        cert.get("guard_overhead", {})
-        if isinstance(cert.get("guard_overhead"), dict)
+        evaluation_report.get("guard_overhead", {})
+        if isinstance(evaluation_report.get("guard_overhead"), dict)
         else {}
     )
     if overhead:

invarlock/cli/commands/export_html.py

@@ -2,7 +2,7 @@
 InvarLock HTML Export
 =================
 
- Thin wrapper over the HTML certificate renderer to make exporting
+ Thin wrapper over the HTML evaluation report renderer to make exporting
  discoverable and scriptable.
 """
 
@@ -20,7 +20,9 @@ console = Console()
 
 
 def export_html_command(
-    input: str = typer.Option(..., "--input", "-i", help="Path to certificate JSON"),
+    input: str = typer.Option(
+        ..., "--input", "-i", help="Path to evaluation report JSON"
+    ),
     output: str = typer.Option(..., "--output", "-o", help="Path to output HTML file"),
     embed_css: bool = typer.Option(
         True,
@@ -31,12 +33,12 @@ def export_html_command(
         False, "--force", help="Overwrite output file if it already exists"
     ),
 ) -> None:
-    """Render a certificate JSON to HTML.
+    """Render an evaluation report JSON to HTML.
 
     Exit codes:
     - 0: success
     - 1: generic failure (IO or overwrite refusal)
-    - 2: validation failure (invalid certificate schema)
+    - 2: validation failure (invalid evaluation report schema)
     """
     # When called programmatically, Typer's Option defaults can be OptionInfo
     try:  # pragma: no cover - defensive, matches other commands' pattern
@@ -70,12 +72,12 @@ def export_html_command(
         raise typer.Exit(1) from exc
 
     try:
-        from invarlock.reporting.html import render_certificate_html
+        from invarlock.reporting.html import render_report_html
 
-        html = render_certificate_html(payload)
+        html = render_report_html(payload)
     except ValueError as exc:
-        # Certificate validation failed upstream
-        console.print(f"[red]❌ Certificate validation failed: {exc}[/red]")
+        # Evaluation report validation failed upstream
+        console.print(f"[red]❌ Evaluation report validation failed: {exc}[/red]")
         raise typer.Exit(2) from exc
     except Exception as exc:
         console.print(f"[red]❌ Failed to render HTML: {exc}[/red]")
@@ -94,7 +96,7 @@ def export_html_command(
         console.print(f"[red]❌ Failed to write output file: {exc}[/red]")
         raise typer.Exit(1) from exc
 
-    console.print(f"✅ Exported certificate HTML → {out_path}")
+    console.print(f"✅ Exported evaluation report HTML → {out_path}")
 
 
 __all__ = ["export_html_command"]