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

invarlock/cli/commands/doctor.py

@@ -188,7 +188,9 @@ def doctor_command(
         None, "--config", "-c", help="Path to YAML config for preflight lints"
     ),
     profile: str | None = typer.Option(
-        None, "--profile", help="Profile to apply for preflight (ci|release)"
+        None,
+        "--profile",
+        help="Profile to apply for preflight (e.g. ci, release, ci_cpu; dev is a no-op)",
     ),
     baseline: str | None = typer.Option(
         None, "--baseline", help="Optional baseline report to check pairing readiness"
@@ -1040,8 +1042,7 @@ def doctor_command(
                 module = str(info.get("module") or "")
                 support = (
                     "auto"
-                    if module.startswith("invarlock.adapters")
-                    and n in {"hf_causal_auto", "hf_mlm_auto"}
+                    if module.startswith("invarlock.adapters") and n in {"hf_auto"}
                     else (
                         "core"
                         if module.startswith("invarlock.adapters")
@@ -1056,11 +1057,10 @@ def doctor_command(
 
                 # Heuristic backend mapping without heavy imports
                 if n in {
-                    "hf_gpt2",
-                    "hf_bert",
-                    "hf_llama",
-                    "hf_causal_auto",
-                    "hf_mlm_auto",
+                    "hf_causal",
+                    "hf_mlm",
+                    "hf_seq2seq",
+                    "hf_auto",
                 }:
                     # Transformers-based
                     backend = "transformers"
@@ -1095,8 +1095,8 @@ def doctor_command(
                         }.get(n)
                         if hint:
                             enable = f"pip install '{hint}'"
-                # Special-case: hf_onnx is a core adapter but requires Optimum/ONNXRuntime
-                if n == "hf_onnx":
+                # Special-case: ONNX causal adapter is core but requires Optimum/ONNXRuntime
+                if n == "hf_causal_onnx":
                     backend = backend or "onnxruntime"
                     present = (
                         importlib.util.find_spec("optimum.onnxruntime") is not None
@@ -1320,7 +1320,7 @@ def doctor_command(
         if "optimum" in str(e).lower():
             if not json_out:
                 console.print(
-                    "  [yellow]⚠️  Optional Optimum/ONNXRuntime missing; hf_onnx will be shown as needs_extra[/yellow]"
+                    "  [yellow]⚠️  Optional Optimum/ONNXRuntime missing; hf_causal_onnx will be shown as needs_extra[/yellow]"
                 )
             # Do not mark overall health as failed for optional extras
         else:

invarlock/cli/commands/explain_gates.py

@@ -99,10 +99,6 @@ def explain_gates_command(
         pm = cert.get("primary_metric", {})
         ratio = pm.get("ratio_vs_baseline")
         ratio_ci = pm.get("display_ci")
-    elif isinstance(cert.get("ppl"), dict):  # legacy
-        ppl = cert.get("ppl", {})
-        ratio = ppl.get("ratio_vs_baseline")
-        ratio_ci = ppl.get("ratio_ci")
     hysteresis_applied = bool(validation.get("hysteresis_applied"))
     status = "PASS" if bool(validation.get("primary_metric_acceptable")) else "FAIL"
     console.print("[bold]Gate: Primary Metric vs Baseline[/bold]")
@@ -125,6 +121,63 @@ def explain_gates_command(
             f"  note: hysteresis applied → effective threshold = {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)
+        else {}
+    )
+    if pm_tail:
+        mode = str(pm_tail.get("mode", "warn") or "warn").strip().lower()
+        evaluated = bool(pm_tail.get("evaluated", False))
+        passed = bool(pm_tail.get("passed", True))
+        policy = (
+            pm_tail.get("policy", {}) if isinstance(pm_tail.get("policy"), dict) else {}
+        )
+        stats = (
+            pm_tail.get("stats", {}) if isinstance(pm_tail.get("stats"), dict) else {}
+        )
+
+        q = policy.get("quantile", 0.95)
+        try:
+            qf = float(q)
+        except Exception:
+            qf = 0.95
+        qf = max(0.0, min(1.0, qf))
+        q_key = f"q{int(round(100.0 * qf))}"
+        q_name = f"P{int(round(100.0 * qf))}"
+        q_val = stats.get(q_key)
+        qmax = policy.get("quantile_max")
+        eps = policy.get("epsilon", stats.get("epsilon"))
+        mass = stats.get("tail_mass")
+        mmax = policy.get("mass_max")
+
+        if not evaluated:
+            status_tail = "INFO"
+        elif passed:
+            status_tail = "PASS"
+        elif mode == "fail":
+            status_tail = "FAIL"
+        else:
+            status_tail = "WARN"
+
+        console.print("\n[bold]Gate: Primary Metric Tail (ΔlogNLL)[/bold]")
+        console.print(f"  mode: {mode}")
+        console.print(f"  status: {status_tail}")
+        if isinstance(q_val, int | float):
+            console.print(f"  observed: {q_name}={float(q_val):.4f}")
+        if isinstance(mass, int | float):
+            console.print(f"  tail_mass: Pr[ΔlogNLL > ε]={float(mass):.4f}")
+        thr_parts: list[str] = []
+        if isinstance(qmax, int | float):
+            thr_parts.append(f"{q_name}≤{float(qmax):.4f}")
+        if isinstance(mmax, int | float):
+            thr_parts.append(f"mass≤{float(mmax):.4f}")
+        if isinstance(eps, int | float):
+            thr_parts.append(f"ε={float(eps):.1e}")
+        if thr_parts:
+            console.print("  threshold: " + "; ".join(thr_parts))
+
     # Dataset split visibility from report provenance
     try:
         split = (report_data.get("provenance", {}) or {}).get("dataset_split")
@@ -151,10 +204,6 @@ def explain_gates_command(
                     drift = float(final) / float(preview)
             except Exception:
                 drift = None
-    if isinstance(cert.get("ppl"), dict):  # legacy
-        ppl = cert.get("ppl", {})
-        drift = ppl.get("preview_final_ratio", drift)
-        drift_ci = ppl.get("drift_ci")
     drift_status = (
         "PASS" if bool(validation.get("preview_final_drift_acceptable")) else "FAIL"
     )

invarlock/cli/commands/plugins.py

@@ -201,9 +201,9 @@ def plugins_command(
                 entry = info.get("entry_point")
                 # Classify support level independent of origin
                 if module.startswith("invarlock.adapters"):
-                    if n in {"hf_causal_auto", "hf_mlm_auto"}:
+                    if n in {"hf_auto"}:
                         support = "auto"
-                    elif n in {"hf_onnx"}:
+                    elif n in {"hf_causal_onnx"}:
                         # ONNX relies on optional extras (optimum + onnxruntime)
                         support = "optional"
                     else:
@@ -236,7 +236,7 @@ def plugins_command(
                 if backend_name in {"auto-gptq", "autoawq"} and not is_linux:
                     status = "unsupported"
                     enable = "Linux-only"
-                # Extras completeness for certain adapters (e.g., hf_onnx needs optimum + onnxruntime)
+                # Extras completeness for certain adapters (e.g., hf_causal_onnx needs optimum + onnxruntime)
                 try:
                     extras_status = _check_plugin_extras(n, "adapters")
                 except Exception:
@@ -883,10 +883,14 @@ def _check_plugin_extras(plugin_name: str, plugin_type: str) -> str:
         "variance": {"packages": [], "extra": ""},
         "rmt": {"packages": [], "extra": ""},
         # Adapter plugins (baked-in only)
-        "hf_gpt2": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
-        "hf_bert": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
-        "hf_llama": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
-        "hf_onnx": {"packages": ["optimum", "onnxruntime"], "extra": "invarlock[onnx]"},
+        "hf_causal": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
+        "hf_mlm": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
+        "hf_seq2seq": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
+        "hf_auto": {"packages": ["transformers"], "extra": "invarlock[adapters]"},
+        "hf_causal_onnx": {
+            "packages": ["optimum", "onnxruntime"],
+            "extra": "invarlock[onnx]",
+        },
         # Optional adapter plugins
         "hf_gptq": {"packages": ["auto_gptq"], "extra": "invarlock[gptq]"},
         "hf_awq": {"packages": ["autoawq"], "extra": "invarlock[awq]"},
@@ -971,7 +975,7 @@ def _resolve_uninstall_targets(target: str) -> list[str]:
         "bitsandbytes": ["bitsandbytes"],
         # ONNX/Optimum family
         "onnx": ["onnxruntime"],
-        "hf_onnx": ["onnxruntime"],
+        "hf_causal_onnx": ["onnxruntime"],
         "optimum": ["optimum"],
     }
     return mapping.get(name, [])
@@ -1010,7 +1014,7 @@ def _resolve_install_targets(target: str) -> list[str]:
         "transformers": ["invarlock[adapters]"],
         # ONNX/Optimum
         "onnx": ["invarlock[onnx]"],
-        "hf_onnx": ["invarlock[onnx]"],
+        "hf_causal_onnx": ["invarlock[onnx]"],
         "optimum": ["invarlock[onnx]"],
         # Direct packages passthrough
         "bitsandbytes": ["bitsandbytes"],

invarlock/cli/commands/report.py

@@ -8,16 +8,84 @@ Provides the `invarlock report` group with:
 """
 
 import json
+import math
 from pathlib import Path
+from typing import Any
 
 import typer
 from rich.console import Console
 
+from invarlock.cli.output import print_event, resolve_output_style
 from invarlock.reporting import certificate as certificate_lib
 from invarlock.reporting import report as report_lib
 
 console = Console()
 
+SECTION_WIDTH = 67
+KV_LABEL_WIDTH = 16
+GATE_LABEL_WIDTH = 32
+ARTIFACT_LABEL_WIDTH = 18
+
+
+def _print_section_header(console: Console, title: str) -> None:
+    bar = "═" * SECTION_WIDTH
+    console.print(bar)
+    console.print(title)
+    console.print(bar)
+
+
+def _format_kv_line(label: str, value: str, *, width: int = KV_LABEL_WIDTH) -> str:
+    return f"  {label:<{width}}: {value}"
+
+
+def _format_status(ok: bool) -> str:
+    return "PASS" if ok else "FAIL"
+
+
+def _fmt_metric_value(value: Any) -> str:
+    try:
+        val = float(value)
+    except (TypeError, ValueError):
+        return "N/A"
+    if not math.isfinite(val):
+        return "N/A"
+    return f"{val:.3f}"
+
+
+def _fmt_ci_range(ci: Any) -> str:
+    if isinstance(ci, (list, tuple)) and len(ci) == 2:
+        try:
+            lo = float(ci[0])
+            hi = float(ci[1])
+        except (TypeError, ValueError):
+            return "N/A"
+        if math.isfinite(lo) and math.isfinite(hi):
+            return f"{lo:.3f}–{hi:.3f}"
+    return "N/A"
+
+
+def _artifact_entries(
+    saved_files: dict[str, str], output_dir: str
+) -> list[tuple[str, str]]:
+    order = [
+        ("cert", "Certificate (JSON)"),
+        ("cert_md", "Certificate (MD)"),
+        ("json", "JSON"),
+        ("markdown", "Markdown"),
+        ("html", "HTML"),
+    ]
+    entries: list[tuple[str, str]] = [("Output", output_dir)]
+    used: set[str] = set()
+    for key, label in order:
+        if key in saved_files:
+            entries.append((label, str(saved_files[key])))
+            used.add(key)
+    for key in sorted(saved_files.keys()):
+        if key in used:
+            continue
+        entries.append((key.upper(), str(saved_files[key])))
+    return entries
+
 
 # Group with callback so `invarlock report` still generates reports
 report_app = typer.Typer(
@@ -33,6 +101,8 @@ def _generate_reports(
     compare: str | None = None,
     baseline: str | None = None,
     output: str | None = None,
+    style: str = "audit",
+    no_color: bool = False,
 ) -> None:
     # This callback runs only when invoked without subcommand (default Click behavior)
     try:
@@ -55,21 +125,34 @@ def _generate_reports(
         compare = _coerce_option(compare)
         baseline = _coerce_option(baseline)
         output = _coerce_option(output)
+        style = _coerce_option(style, "audit")
+        no_color = bool(_coerce_option(no_color, False))
+
+        output_style = resolve_output_style(
+            style=str(style),
+            profile="ci",
+            progress=False,
+            timing=False,
+            no_color=no_color,
+        )
+
+        def _event(tag: str, message: str, *, emoji: str | None = None) -> None:
+            print_event(console, tag, message, style=output_style, emoji=emoji)
 
         # Load primary report
-        console.print(f"📊 Loading run report: {run}")
+        _event("DATA", f"Loading run report: {run}", emoji="📊")
         primary_report = _load_run_report(run)
 
         # Load comparison report if specified
         compare_report = None
         if compare:
-            console.print(f"📊 Loading comparison report: {compare}")
+            _event("DATA", f"Loading comparison report: {compare}", emoji="📊")
             compare_report = _load_run_report(compare)
 
         # Load baseline report if specified
         baseline_report = None
         if baseline:
-            console.print(f"📊 Loading baseline report: {baseline}")
+            _event("DATA", f"Loading baseline report: {baseline}", emoji="📊")
             baseline_report = _load_run_report(baseline)
 
         # Determine output directory
@@ -88,17 +171,20 @@ def _generate_reports(
         # Validate certificate requirements
         if "cert" in formats:
             if baseline_report is None:
-                console.print(
-                    "[red]❌ Certificate format requires --baseline parameter[/red]"
-                )
-                console.print(
-                    "Use: invarlock report --run <run_dir> --format cert --baseline <baseline_run_dir>"
+                _event("FAIL", "Certificate format requires --baseline", emoji="❌")
+                _event(
+                    "INFO",
+                    "Use: invarlock report --run <run_dir> --format cert --baseline <baseline_run_dir>",
                 )
                 raise typer.Exit(1)
-            console.print("📜 Generating safety certificate with baseline comparison")
+            _event(
+                "EXEC",
+                "Generating evaluation certificate with baseline comparison",
+                emoji="📜",
+            )
 
         # Generate reports
-        console.print(f"📝 Generating reports in formats: {formats}")
+        _event("EXEC", f"Generating reports in formats: {formats}", emoji="📝")
         saved_files = report_lib.save_report(
             primary_report,
             output_dir,
@@ -109,40 +195,8 @@ def _generate_reports(
         )
 
         # Show results
-        console.print("[green]✅ Reports generated successfully![/green]")
-        console.print(f"📁 Output directory: {output_dir}")
-
-        for fmt, file_path in saved_files.items():
-            if fmt == "cert":
-                console.print(f"  📜 CERTIFICATE (JSON): {file_path}")
-            elif fmt == "cert_md":
-                console.print(f"  📜 CERTIFICATE (MD): {file_path}")
-            else:
-                console.print(f"  📄 {fmt.upper()}: {file_path}")
-
-        # Show key metrics (PM-first). Avoid legacy PPL wording.
-        console.print("\n📈 Key Metrics:")
-        console.print(f"  Model: {primary_report['meta']['model_id']}")
-        console.print(f"  Edit: {primary_report['edit']['name']}")
-        pm = (primary_report.get("metrics", {}) or {}).get("primary_metric", {})
-        if isinstance(pm, dict) and pm:
-            kind = str(pm.get("kind") or "primary")
-            console.print(f"  Primary Metric: {kind}")
-            final = pm.get("final")
-            if isinstance(final, int | float):
-                console.print(f"  point (final): {final:.3f}")
-            dci = pm.get("display_ci")
-            if isinstance(dci, tuple | list) and len(dci) == 2:
-                try:
-                    lo, hi = float(dci[0]), float(dci[1])
-                    console.print(f"  CI: {lo:.3f}–{hi:.3f}")
-                except Exception:
-                    pass
-            ratio = pm.get("ratio_vs_baseline")
-            if isinstance(ratio, int | float):
-                console.print(f"  ratio vs baseline: {ratio:.3f}")
-
-        # Show certificate validation if generated
+        _event("PASS", "Reports generated successfully.", emoji="✅")
+
         if "cert" in formats and baseline_report:
             try:
                 certificate = certificate_lib.make_certificate(
@@ -155,36 +209,105 @@ def _generate_reports(
 
                 block = _console_block(certificate)
                 overall_pass = bool(block.get("overall_pass"))
+                status_text = _format_status(overall_pass)
 
-                console.print("\n📜 Certificate Validation:")
-                status_emoji = "✅" if overall_pass else "❌"
-                console.print(
-                    f"  Overall Status: {status_emoji} {'PASS' if overall_pass else 'FAIL'}"
-                )
+                console.print("")
+                _print_section_header(console, "CERTIFICATE SUMMARY")
+                console.print(_format_kv_line("Status", status_text))
 
+                schema_version = certificate.get("schema_version")
+                if schema_version:
+                    console.print(
+                        _format_kv_line("Schema Version", str(schema_version))
+                    )
+
+                run_id = certificate.get("run_id") or (
+                    (primary_report.get("meta", {}) or {}).get("run_id")
+                )
+                if run_id:
+                    console.print(_format_kv_line("Run ID", str(run_id)))
+
+                model_id = (primary_report.get("meta", {}) or {}).get("model_id")
+                edit_name = (primary_report.get("edit", {}) or {}).get("name")
+                if model_id:
+                    console.print(_format_kv_line("Model", str(model_id)))
+                if edit_name:
+                    console.print(_format_kv_line("Edit", str(edit_name)))
+
+                pm = (primary_report.get("metrics", {}) or {}).get("primary_metric", {})
+                console.print("  PRIMARY METRIC")
+                pm_entries: list[tuple[str, str]] = []
+                if isinstance(pm, dict) and pm:
+                    kind = str(pm.get("kind") or "primary")
+                    pm_entries.append(("Kind", kind))
+                    preview = pm.get("preview")
+                    if preview is not None:
+                        pm_entries.append(("Preview", _fmt_metric_value(preview)))
+                    final = pm.get("final")
+                    if final is not None:
+                        pm_entries.append(("Final", _fmt_metric_value(final)))
+                    ratio = pm.get("ratio_vs_baseline")
+                    if ratio is not None:
+                        pm_entries.append(("Ratio", _fmt_metric_value(ratio)))
+                    dci = pm.get("display_ci")
+                    if dci is not None:
+                        pm_entries.append(("CI", _fmt_ci_range(dci)))
+                if not pm_entries:
+                    pm_entries.append(("Status", "Unavailable"))
+                for idx, (label, value) in enumerate(pm_entries):
+                    branch = "└─" if idx == len(pm_entries) - 1 else "├─"
+                    console.print(f"  {branch} {label:<14} {value}")
+
+                console.print("  VALIDATION GATES")
                 rows = block.get("rows", [])
                 if isinstance(rows, list) and rows:
-                    for row in rows:
-                        try:
-                            label = row.get("label")
-                            status = row.get("status")
-                            if label and status:
-                                console.print(f"  {label}: {status}")
-                        except Exception:
-                            continue
+                    for idx, row in enumerate(rows):
+                        label = str(row.get("label") or "Unknown")
+                        ok = bool(row.get("ok"))
+                        status = _format_status(ok)
+                        mark = "✓" if ok else "✗"
+                        branch = "└─" if idx == len(rows) - 1 else "├─"
+                        console.print(
+                            f"  {branch} {label:<{GATE_LABEL_WIDTH}} {mark} {status}"
+                        )
+                else:
+                    console.print(f"  └─ {'No validation rows':<{GATE_LABEL_WIDTH}} -")
+
+                console.print("  ARTIFACTS")
+                entries = _artifact_entries(saved_files, str(output_dir))
+                for idx, (label, value) in enumerate(entries):
+                    branch = "└─" if idx == len(entries) - 1 else "├─"
+                    console.print(f"  {branch} {label:<{ARTIFACT_LABEL_WIDTH}} {value}")
+                console.print("═" * SECTION_WIDTH)
 
                 # In CLI report flow, do not hard-exit on validation failure; just display status.
                 # CI gating should be handled by dedicated verify commands.
 
             except Exception as e:
-                console.print(
-                    f"  [yellow]⚠️  Certificate validation error: {e}[/yellow]"
-                )
+                _event("WARN", f"Certificate validation error: {e}", emoji="⚠️")
                 # Exit non-zero on certificate generation error
                 raise typer.Exit(1) from e
+        else:
+            console.print(_format_kv_line("Output", str(output_dir)))
+            for label, value in _artifact_entries(saved_files, str(output_dir))[1:]:
+                console.print(
+                    _format_kv_line(label, str(value), width=ARTIFACT_LABEL_WIDTH)
+                )
 
     except Exception as e:
-        console.print(f"[red]❌ Report generation failed: {e}[/red]")
+        print_event(
+            console,
+            "FAIL",
+            f"Report generation failed: {e}",
+            style=resolve_output_style(
+                style="audit",
+                profile="ci",
+                progress=False,
+                timing=False,
+                no_color=False,
+            ),
+            emoji="❌",
+        )
         raise typer.Exit(1) from e
 
 
@@ -206,15 +329,37 @@ def report_callback(
         help="Path to baseline run for certificate generation (required for cert format)",
     ),
     output: str | None = typer.Option(None, "--output", "-o", help="Output directory"),
+    style: str = typer.Option("audit", "--style", help="Output style (audit|friendly)"),
+    no_color: bool = typer.Option(
+        False, "--no-color", help="Disable ANSI colors (respects NO_COLOR=1)"
+    ),
 ):
     """Generate a report from a run (default callback)."""
     if getattr(ctx, "resilient_parsing", False) or ctx.invoked_subcommand is not None:
         return
     if not run:
-        console.print("[red]❌ --run is required when no subcommand is provided[/red]")
+        print_event(
+            console,
+            "FAIL",
+            "--run is required when no subcommand is provided",
+            style=resolve_output_style(
+                style=str(style),
+                profile="ci",
+                progress=False,
+                timing=False,
+                no_color=no_color,
+            ),
+            emoji="❌",
+        )
         raise typer.Exit(2)
     return _generate_reports(
-        run=run, format=format, compare=compare, baseline=baseline, output=output
+        run=run,
+        format=format,
+        compare=compare,
+        baseline=baseline,
+        output=output,
+        style=style,
+        no_color=no_color,
     )
 
 
@@ -225,9 +370,17 @@ def report_command(
     compare: str | None = None,
     baseline: str | None = None,
     output: str | None = None,
+    style: str = "audit",
+    no_color: bool = False,
 ):
     return _generate_reports(
-        run=run, format=format, compare=compare, baseline=baseline, output=output
+        run=run,
+        format=format,
+        compare=compare,
+        baseline=baseline,
+        output=output,
+        style=style,
+        no_color=no_color,
     )
 
 
@@ -326,11 +479,22 @@ def report_validate(
     ),
 ):
     """Validate a certificate JSON against the current schema (v1)."""
+    output_style = resolve_output_style(
+        style="audit",
+        profile="ci",
+        progress=False,
+        timing=False,
+        no_color=False,
+    )
+
+    def _event(tag: str, message: str, *, emoji: str | None = None) -> None:
+        print_event(console, tag, message, style=output_style, emoji=emoji)
+
     p = Path(report)
     try:
         payload = json.loads(p.read_text(encoding="utf-8"))
     except Exception as exc:  # noqa: BLE001
-        console.print(f"[red]❌ Failed to read input JSON: {exc}[/red]")
+        _event("FAIL", f"Failed to read input JSON: {exc}", emoji="❌")
         raise typer.Exit(1) from exc
 
     try:
@@ -338,16 +502,16 @@ def report_validate(
 
         ok = validate_certificate(payload)
         if not ok:
-            console.print("[red]❌ Certificate schema validation failed[/red]")
+            _event("FAIL", "Certificate schema validation failed", emoji="❌")
             raise typer.Exit(2)
-        console.print("✅ Certificate schema is valid")
+        _event("PASS", "Certificate schema is valid", emoji="✅")
     except ValueError as exc:
-        console.print(f"[red]❌ Certificate validation error: {exc}[/red]")
+        _event("FAIL", f"Certificate validation error: {exc}", emoji="❌")
         raise typer.Exit(2) from exc
     except typer.Exit:
         raise
     except Exception as exc:  # noqa: BLE001
-        console.print(f"[red]❌ Validation failed: {exc}[/red]")
+        _event("FAIL", f"Validation failed: {exc}", emoji="❌")
         raise typer.Exit(1) from exc