invarlock 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

invarlock/cli/commands/explain_gates.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import typer
 from rich.console import Console
 
-from invarlock.core.auto_tuning import TIER_POLICIES
+from invarlock.core.auto_tuning import get_tier_policies
 from invarlock.reporting.certificate import make_certificate
 
 console = Console()
@@ -49,15 +49,38 @@ def explain_gates_command(
         "aggressive": 1.20,
         "none": 1.10,
     }
-    limit_base = tier_thresholds.get(tier, 1.10)
+    resolved_policy = (
+        cert.get("resolved_policy", {})
+        if isinstance(cert.get("resolved_policy"), dict)
+        else {}
+    )
     metrics_policy = (
-        TIER_POLICIES.get(tier, {}).get("metrics", {}) if isinstance(tier, str) else {}
+        resolved_policy.get("metrics", {})
+        if isinstance(resolved_policy.get("metrics"), dict)
+        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 {}
+        )
+        if not isinstance(metrics_policy, dict):
+            metrics_policy = {}
     pm_policy = (
-        metrics_policy.get("pm_ratio", {}) if isinstance(metrics_policy, dict) else {}
+        metrics_policy.get("pm_ratio", {})
+        if isinstance(metrics_policy.get("pm_ratio"), dict)
+        else {}
     )
     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)
+        )
+    except Exception:
+        limit_base = tier_thresholds.get(tier, 1.10)
     limit_with_hyst = limit_base + max(0.0, hysteresis_ratio)
     tokens_ok = True
     telem = cert.get("telemetry", {}) if isinstance(cert.get("telemetry"), dict) else {}
@@ -70,9 +93,16 @@ def explain_gates_command(
         tokens_ok = True
 
     # Primary-metric ratio gate explanation (ppl-like kinds shown as ratios)
-    ppl = cert.get("ppl", {}) if isinstance(cert.get("ppl"), dict) else {}
-    ratio = ppl.get("ratio_vs_baseline")
-    ratio_ci = ppl.get("ratio_ci")
+    ratio = None
+    ratio_ci = None
+    if isinstance(cert.get("primary_metric"), dict):
+        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]")
@@ -109,8 +139,22 @@ def explain_gates_command(
         pass
 
     # Drift gate explanation
-    drift = ppl.get("preview_final_ratio")
-    drift_ci = ppl.get("drift_ci")
+    drift = None
+    drift_ci = None
+    if isinstance(cert.get("primary_metric"), dict):
+        pm = cert.get("primary_metric", {})
+        preview = pm.get("preview")
+        final = pm.get("final")
+        if isinstance(preview, int | float) and isinstance(final, int | float):
+            try:
+                if float(preview) != 0.0:
+                    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

@@ -897,11 +897,21 @@ def _check_plugin_extras(plugin_name: str, plugin_type: str) -> str:
     if not plugin_info or not plugin_info["packages"]:
         return ""  # No extra dependencies needed
 
-    # Check each required package using import to play nice with tests that mock __import__
+    # Check each required package. For most packages we use a light import so
+    # tests can monkeypatch __import__; for GPU-only stacks like bitsandbytes
+    # we only probe presence via importlib.util.find_spec to avoid crashing on
+    # CPU-only builds during simple listing.
     missing_packages: list[str] = []
     for pkg in plugin_info["packages"]:
         try:
-            __import__(pkg)
+            if pkg == "bitsandbytes":
+                import importlib.util as _util
+
+                spec = _util.find_spec(pkg)
+                if spec is None:
+                    raise ImportError("bitsandbytes not importable")
+            else:
+                __import__(pkg)
         except Exception:
             missing_packages.append(pkg)
 

invarlock/cli/commands/run.py

@@ -9,6 +9,7 @@ prefer Compare & Certify via `invarlock certify --baseline ... --subject ...`.
 
 import copy
 import hashlib
+import inspect
 import json
 import math
 import os
@@ -81,6 +82,137 @@ GUARD_OVERHEAD_THRESHOLD = 0.01
 SPLIT_ALIASES: tuple[str, ...] = ("validation", "val", "dev", "eval", "test")
 
 
+def _coerce_mapping(obj: object) -> dict[str, Any]:
+    """Best-effort conversion of config-like objects to plain dicts."""
+
+    if isinstance(obj, dict):
+        return obj
+    try:
+        raw = getattr(obj, "_data", None)
+        if isinstance(raw, dict):
+            return raw
+    except Exception:
+        pass
+    try:
+        dumped = obj.model_dump()  # type: ignore[attr-defined]
+        if isinstance(dumped, dict):
+            return dumped
+    except Exception:
+        pass
+    try:
+        data = vars(obj)
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return {}
+
+
+def _resolve_pm_acceptance_range(
+    cfg: InvarLockConfig | dict[str, Any] | None,
+) -> dict[str, float]:
+    """Resolve primary-metric acceptance bounds from config/env with safe defaults."""
+
+    base_min = 0.95
+    base_max = 1.10
+
+    cfg_min = None
+    cfg_max = None
+    try:
+        cfg_map = _coerce_mapping(cfg) if cfg is not None else {}
+        pm_section = cfg_map.get("primary_metric") if isinstance(cfg_map, dict) else {}
+        pm_map = _coerce_mapping(pm_section)
+        acceptance = (
+            pm_map.get("acceptance_range") if isinstance(pm_map, dict) else None
+        )
+        if isinstance(acceptance, dict):
+            if acceptance.get("min") is not None:
+                try:
+                    cfg_min = float(acceptance["min"])
+                except (TypeError, ValueError):
+                    cfg_min = None
+            if acceptance.get("max") is not None:
+                try:
+                    cfg_max = float(acceptance["max"])
+                except (TypeError, ValueError):
+                    cfg_max = None
+    except Exception:
+        cfg_min = None
+        cfg_max = None
+
+    def _parse_env(name: str) -> float | None:
+        try:
+            raw = os.environ.get(name, "")
+            if raw is None or str(raw).strip() == "":
+                return None
+            return float(raw)
+        except Exception:
+            return None
+
+    env_min = _parse_env("INVARLOCK_PM_ACCEPTANCE_MIN")
+    env_max = _parse_env("INVARLOCK_PM_ACCEPTANCE_MAX")
+
+    has_explicit = any(v is not None for v in (cfg_min, cfg_max, env_min, env_max))
+    if not has_explicit:
+        return {}
+
+    min_val = (
+        env_min if env_min is not None else cfg_min if cfg_min is not None else base_min
+    )
+    max_val = (
+        env_max if env_max is not None else cfg_max if cfg_max is not None else base_max
+    )
+
+    try:
+        if min_val is not None and min_val <= 0:
+            min_val = base_min
+    except Exception:
+        min_val = base_min
+    try:
+        if max_val is not None and max_val <= 0:
+            max_val = base_max
+    except Exception:
+        max_val = base_max
+
+    try:
+        if max_val is not None and min_val is not None and max_val < min_val:
+            max_val = min_val
+    except Exception:
+        max_val = base_max
+
+    return {"min": float(min_val), "max": float(max_val)}
+
+
+def _free_model_memory(model: object | None) -> None:
+    """Best-effort cleanup to release GPU memory for a model object."""
+    if model is None:
+        return
+    try:
+        import gc
+
+        del model
+        gc.collect()
+        if torch is not None and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+    except Exception:
+        # Cleanup should never raise; fallback is to proceed without cache purge
+        pass
+
+
+def _should_measure_overhead(profile_normalized: str) -> tuple[bool, bool]:
+    """Return (measure_guard_overhead, skip_overhead) derived from env/profile."""
+
+    skip_overhead_env = (
+        os.environ.get("INVARLOCK_SKIP_OVERHEAD_CHECK", "").strip().lower()
+    )
+    skip_overhead = skip_overhead_env in {"1", "true", "yes"}
+    measure_guard_overhead = (
+        profile_normalized in {"ci", "release"} and not skip_overhead
+    )
+    return measure_guard_overhead, skip_overhead
+
+
 def _choose_dataset_split(
     *, requested: str | None, available: list[str] | None
 ) -> tuple[str, bool]:
@@ -687,6 +819,51 @@ def _resolve_provider_and_split(
     return data_provider, resolved_split, used_fallback_split
 
 
+def _extract_model_load_kwargs(cfg: InvarLockConfig) -> dict[str, Any]:
+    """Return adapter.load_model kwargs from config (excluding core fields)."""
+    try:
+        data = cfg.model_dump()
+    except Exception:
+        data = {}
+    model = data.get("model") if isinstance(data, dict) else None
+    if not isinstance(model, dict):
+        return {}
+    return {
+        key: value
+        for key, value in model.items()
+        if key not in {"id", "adapter", "device"} and value is not None
+    }
+
+
+def _load_model_with_cfg(adapter: Any, cfg: InvarLockConfig, device: str) -> Any:
+    """Load a model with config-provided kwargs, filtering for strict adapters."""
+    try:
+        model_id = cfg.model.id
+    except Exception:
+        try:
+            model_id = (cfg.model_dump().get("model") or {}).get("id")
+        except Exception:
+            model_id = None
+    if not isinstance(model_id, str) or not model_id:
+        raise ValueError("Missing model.id in config")
+
+    extra = _extract_model_load_kwargs(cfg)
+    try:
+        sig = inspect.signature(adapter.load_model)
+        accepts_var_kw = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+        )
+        if accepts_var_kw:
+            return adapter.load_model(model_id, device=device, **extra)
+        allowed = {k: v for k, v in extra.items() if k in sig.parameters}
+        if allowed:
+            return adapter.load_model(model_id, device=device, **allowed)
+    except Exception:
+        # Fall back to the strictest call shape.
+        pass
+    return adapter.load_model(model_id, device=device)
+
+
 def _run_bare_control(
     *,
     adapter: Any,
@@ -768,6 +945,7 @@ def _run_bare_control(
         "errors": [],
         "checks": {},
         "source": f"{profile_normalized or 'ci'}_profile",
+        "mode": "bare",
     }
 
     if getattr(bare_report, "status", "").lower() not in {"success", "completed", "ok"}:
@@ -846,7 +1024,7 @@ def _postprocess_and_summarize(
     match_fraction: float | None,
     overlap_fraction: float | None,
     console: Console,
-) -> None:
+) -> dict[str, str]:
     """Finalize report windows stats and print/save summary artifacts."""
     try:
         ds = report.setdefault("dataset", {}).setdefault("windows", {})
@@ -870,6 +1048,7 @@ def _postprocess_and_summarize(
     console.print(f"📄 Report: {saved_files['json']}")
     if run_config.event_path:
         console.print(f"📝 Events: {run_config.event_path}")
+    return saved_files
 
 
 def _compute_provider_digest(report: dict[str, Any]) -> dict[str, str] | None:
@@ -1406,6 +1585,7 @@ def run_command(
     no_cleanup = bool(_coerce_option(no_cleanup, False))
 
     # Use shared CLI coercers from invarlock.cli.utils
+    report_path_out: str | None = None
 
     def _fail_run(message: str) -> None:
         console.print(f"[red]❌ {message}[/red]")
@@ -1542,6 +1722,26 @@ def run_command(
             cfg, device=device, out=out, console=console
         )
 
+        determinism_meta: dict[str, Any] | None = None
+        try:
+            from invarlock.cli.determinism import apply_determinism_preset
+
+            preset = apply_determinism_preset(
+                profile=profile_label,
+                device=resolved_device,
+                seed=int(seed_bundle.get("python") or seed_value),
+                threads=int(os.environ.get("INVARLOCK_OMP_THREADS", 1) or 1),
+            )
+            if isinstance(preset, dict) and preset:
+                determinism_meta = preset
+                preset_seeds = preset.get("seeds")
+                if isinstance(preset_seeds, dict) and preset_seeds:
+                    for key in ("python", "numpy", "torch"):
+                        if key in preset_seeds:
+                            seed_bundle[key] = preset_seeds.get(key)
+        except Exception:
+            determinism_meta = None
+
         # Create run directory with timestamp
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         run_dir = output_dir / timestamp
@@ -1671,6 +1871,7 @@ def run_command(
             "edit": edit_meta,
             "guards": guard_metadata,
         }
+        pm_acceptance_range = _resolve_pm_acceptance_range(cfg)
 
         console.print(f"🔌 Adapter: {adapter.name}")
 
@@ -1746,6 +1947,10 @@ def run_command(
             "plugins": plugin_provenance,
             "run_id": run_id,
         }
+        run_context.setdefault("primary_metric", {})["acceptance_range"] = (
+            pm_acceptance_range
+        )
+        run_context["pm_acceptance_range"] = pm_acceptance_range
         run_context["model_profile"] = {
             "family": model_profile.family,
             "default_loss": model_profile.default_loss,
@@ -2756,18 +2961,26 @@ def run_command(
 
                 restore_fn = _restore2
             else:
-                # reload path
+                # reload path - properly free GPU memory before setting to None
+                _free_model_memory(model)
                 model = None
                 restore_fn = None
         except Exception:
             # On any failure, fall back to reload-per-attempt path
+            _free_model_memory(model)
             model = None
             restore_fn = None
 
         # RETRY LOOP - All report processing inside loop
         attempt = 1
         profile_normalized = (profile or "").lower()
-        measure_guard_overhead = profile_normalized in {"ci", "release"}
+        measure_guard_overhead, skip_overhead = _should_measure_overhead(
+            profile_normalized
+        )
+        if skip_overhead and profile_normalized in {"ci", "release"}:
+            console.print(
+                "[yellow]⚠️  Overhead check skipped via INVARLOCK_SKIP_OVERHEAD_CHECK[/yellow]"
+            )
 
         while True:
             # Reset RNG streams each attempt to guarantee determinism across retries
@@ -2790,7 +3003,23 @@ def run_command(
                 )
 
             guard_overhead_payload: dict[str, Any] | None = None
-            if measure_guard_overhead:
+            if skip_overhead and profile_normalized in {"ci", "release"}:
+                guard_overhead_payload = {
+                    "overhead_threshold": GUARD_OVERHEAD_THRESHOLD,
+                    "evaluated": False,
+                    "passed": True,
+                    "skipped": True,
+                    "skip_reason": "INVARLOCK_SKIP_OVERHEAD_CHECK",
+                    "mode": "skipped",
+                    "source": "env:INVARLOCK_SKIP_OVERHEAD_CHECK",
+                    "messages": [
+                        "Overhead check skipped via INVARLOCK_SKIP_OVERHEAD_CHECK"
+                    ],
+                    "warnings": [],
+                    "errors": [],
+                    "checks": {},
+                }
+            elif measure_guard_overhead:
                 guard_overhead_payload = _run_bare_control(
                     adapter=adapter,
                     edit_op=edit_op,
@@ -2932,7 +3161,11 @@ def run_command(
                 meta_payload["invarlock_version"] = invarlock_version
             if env_flags:
                 meta_payload["env_flags"] = env_flags
+            if determinism_meta:
+                meta_payload["determinism"] = determinism_meta
             report["meta"].update(meta_payload)
+            if pm_acceptance_range:
+                report["meta"]["pm_acceptance_range"] = pm_acceptance_range
             report["meta"]["model_profile"] = {
                 "family": model_profile.family,
                 "default_loss": model_profile.default_loss,
@@ -3089,87 +3322,90 @@ def run_command(
                 report["metrics"].update(metrics_payload)
 
             if guard_overhead_payload is not None:
-                # Compute guarded primary-metric snapshot; pass structured reports into validator
-                try:
-                    # Map loss type to ppl family kind
-                    lk = str(resolved_loss_type or "causal").lower()
-                    if lk == "mlm":
-                        pm_kind_for_overhead = "ppl_mlm"
-                    elif lk in {"seq2seq", "s2s", "t5"}:
-                        pm_kind_for_overhead = "ppl_seq2seq"
-                    else:
-                        pm_kind_for_overhead = "ppl_causal"
+                if bool(guard_overhead_payload.get("skipped", False)):
+                    report["guard_overhead"] = guard_overhead_payload
+                else:
+                    # Compute guarded primary-metric snapshot; pass structured reports into validator
+                    try:
+                        # Map loss type to ppl family kind
+                        lk = str(resolved_loss_type or "causal").lower()
+                        if lk == "mlm":
+                            pm_kind_for_overhead = "ppl_mlm"
+                        elif lk in {"seq2seq", "s2s", "t5"}:
+                            pm_kind_for_overhead = "ppl_seq2seq"
+                        else:
+                            pm_kind_for_overhead = "ppl_causal"
 
-                    # Prefer computing from the in-memory core_report windows to avoid ordering issues
-                    pm_guarded = _extract_pm_snapshot_for_overhead(
-                        core_report, kind=pm_kind_for_overhead
-                    )
-                    if not isinstance(pm_guarded, dict) or not pm_guarded:
+                        # Prefer computing from the in-memory core_report windows to avoid ordering issues
                         pm_guarded = _extract_pm_snapshot_for_overhead(
-                            report, kind=pm_kind_for_overhead
+                            core_report, kind=pm_kind_for_overhead
                         )
+                        if not isinstance(pm_guarded, dict) or not pm_guarded:
+                            pm_guarded = _extract_pm_snapshot_for_overhead(
+                                report, kind=pm_kind_for_overhead
+                            )
 
-                    guard_overhead_payload["guarded_report"] = (
-                        {"metrics": {"primary_metric": pm_guarded}}
-                        if isinstance(pm_guarded, dict) and pm_guarded
-                        else None
+                        guard_overhead_payload["guarded_report"] = (
+                            {"metrics": {"primary_metric": pm_guarded}}
+                            if isinstance(pm_guarded, dict) and pm_guarded
+                            else None
+                        )
+                    except Exception:
+                        guard_overhead_payload["guarded_report"] = None
+                    bare_struct = guard_overhead_payload.get("bare_report") or {}
+                    guarded_struct = guard_overhead_payload.get("guarded_report") or {}
+                    # Be robust to mocks or minimal objects returned by validators
+                    result = validate_guard_overhead(
+                        bare_struct,
+                        guarded_struct,
+                        overhead_threshold=guard_overhead_payload.get(
+                            "overhead_threshold", GUARD_OVERHEAD_THRESHOLD
+                        ),
                     )
-                except Exception:
-                    guard_overhead_payload["guarded_report"] = None
-                bare_struct = guard_overhead_payload.get("bare_report") or {}
-                guarded_struct = guard_overhead_payload.get("guarded_report") or {}
-                # Be robust to mocks or minimal objects returned by validators
-                result = validate_guard_overhead(
-                    bare_struct,
-                    guarded_struct,
-                    overhead_threshold=guard_overhead_payload.get(
-                        "overhead_threshold", GUARD_OVERHEAD_THRESHOLD
-                    ),
-                )
-                try:
-                    messages = list(getattr(result, "messages", []))
-                except Exception:  # pragma: no cover - defensive
-                    messages = []
-                try:
-                    warnings = list(getattr(result, "warnings", []))
-                except Exception:  # pragma: no cover - defensive
-                    warnings = []
-                try:
-                    errors = list(getattr(result, "errors", []))
-                except Exception:  # pragma: no cover - defensive
-                    errors = []
-                try:
-                    checks = dict(getattr(result, "checks", {}))
-                except Exception:  # pragma: no cover - defensive
-                    checks = {}
-                metrics_obj = getattr(result, "metrics", {})
-                if not isinstance(metrics_obj, dict):
-                    metrics_obj = {}
-                overhead_ratio = metrics_obj.get("overhead_ratio")
-                if overhead_ratio is None:
-                    overhead_ratio = getattr(result, "overhead_ratio", None)
-                overhead_percent = metrics_obj.get("overhead_percent")
-                if overhead_percent is None:
-                    overhead_percent = getattr(result, "overhead_percent", None)
-                passed_flag = bool(getattr(result, "passed", False))
-
-                guard_overhead_payload.update(
-                    {
-                        "messages": messages,
-                        "warnings": warnings,
-                        "errors": errors,
-                        "checks": checks,
-                        "overhead_ratio": overhead_ratio,
-                        "overhead_percent": overhead_percent,
-                        "passed": passed_flag,
-                        "evaluated": True,
-                    }
-                )
-                # Normalize for non-finite/degenerate cases
-                guard_overhead_payload = _normalize_overhead_result(
-                    guard_overhead_payload, profile=profile_normalized
-                )
-                report["guard_overhead"] = guard_overhead_payload
+                    try:
+                        messages = list(getattr(result, "messages", []))
+                    except Exception:  # pragma: no cover - defensive
+                        messages = []
+                    try:
+                        warnings = list(getattr(result, "warnings", []))
+                    except Exception:  # pragma: no cover - defensive
+                        warnings = []
+                    try:
+                        errors = list(getattr(result, "errors", []))
+                    except Exception:  # pragma: no cover - defensive
+                        errors = []
+                    try:
+                        checks = dict(getattr(result, "checks", {}))
+                    except Exception:  # pragma: no cover - defensive
+                        checks = {}
+                    metrics_obj = getattr(result, "metrics", {})
+                    if not isinstance(metrics_obj, dict):
+                        metrics_obj = {}
+                    overhead_ratio = metrics_obj.get("overhead_ratio")
+                    if overhead_ratio is None:
+                        overhead_ratio = getattr(result, "overhead_ratio", None)
+                    overhead_percent = metrics_obj.get("overhead_percent")
+                    if overhead_percent is None:
+                        overhead_percent = getattr(result, "overhead_percent", None)
+                    passed_flag = bool(getattr(result, "passed", False))
+
+                    guard_overhead_payload.update(
+                        {
+                            "messages": messages,
+                            "warnings": warnings,
+                            "errors": errors,
+                            "checks": checks,
+                            "overhead_ratio": overhead_ratio,
+                            "overhead_percent": overhead_percent,
+                            "passed": passed_flag,
+                            "evaluated": True,
+                        }
+                    )
+                    # Normalize for non-finite/degenerate cases
+                    guard_overhead_payload = _normalize_overhead_result(
+                        guard_overhead_payload, profile=profile_normalized
+                    )
+                    report["guard_overhead"] = guard_overhead_payload
 
             had_baseline = bool(baseline and Path(baseline).exists())
             if (
@@ -3714,7 +3950,7 @@ def run_command(
             except Exception:
                 pass
 
-            _postprocess_and_summarize(
+            saved_files = _postprocess_and_summarize(
                 report=report,
                 run_dir=run_dir,
                 run_config=run_config,
@@ -3724,6 +3960,11 @@ def run_command(
                 overlap_fraction=overlap_fraction,
                 console=console,
             )
+            try:
+                if isinstance(saved_files, dict) and saved_files.get("json"):
+                    report_path_out = str(saved_files["json"])
+            except Exception:
+                pass
 
             # Metrics display
             pm_obj = None
@@ -3914,6 +4155,7 @@ def run_command(
             pass
 
         # Normal path falls through; cleanup handled below in finally
+        return report_path_out
 
     except FileNotFoundError as e:
         console.print(f"[red]❌ Configuration file not found: {e}[/red]")