@@ -173,12 +173,11 @@ def _nvrtc_version() -> tuple[int, int]:
 def _linker_backend_and_version(use_driver: bool) -> tuple[str, str]:
     """Return ``(backend, version)`` for the linker used on PTX inputs.
 
-    ``use_driver`` is the result of ``_decide_nvjitlink_or_driver()`` and
-    must be passed in so a single ``make_program_cache_key`` call shares
-    one probe across :meth:`_LinkerBackend.validate`,
-    :meth:`option_fingerprint`, and :meth:`hash_version_probe` (otherwise
-    a transient probe flap could write inconsistent fields into the same
-    key).
+    ``use_driver`` is the cached result of the Linker's ``_choose_backend()``
+    decision and must be passed in so a single ``make_program_cache_key`` call
+    shares one probe across :meth:`_LinkerBackend.validate`,
+    :meth:`option_fingerprint`, and :meth:`hash_version_probe` (otherwise a
+    transient probe flap could write inconsistent fields into the same key).
 
     Raises any underlying probe exception. ``make_program_cache_key`` catches
     and mixes the exception's class name into the digest, so the same probe
@@ -187,9 +186,9 @@ def _linker_backend_and_version(use_driver: bool) -> tuple[str, str]:
     working probe (``_probe_failed`` label vs. ``driver``/``nvrtc``/...).
 
     nvJitLink version lookup goes through ``sys.modules`` first so we hit the
-    same module ``_decide_nvjitlink_or_driver()`` already loaded. That keeps
-    fingerprinting aligned with whichever ``cuda.bindings.nvjitlink`` import
-    path the linker actually uses.
+    same module the Linker probe already loaded. That keeps fingerprinting
+    aligned with whichever ``cuda.bindings.nvjitlink`` import path the linker
+    actually uses.
     """
     import sys
 
@@ -483,9 +482,21 @@ def _decide_driver(self) -> bool | None:
         """
         if self._cached_decision is _DECISION_UNSET:
             try:
-                from cuda.core._linker import _decide_nvjitlink_or_driver
-
-                self._cached_decision = _decide_nvjitlink_or_driver()
+                from cuda.core import _linker
+
+                try:
+                    driver_major = _linker.driver_version()[0]
+                except _linker.CUDAError:
+                    driver_major = None
+                self._cached_decision = (
+                    _linker._choose_backend(
+                        driver_major,
+                        _linker._probe_nvjitlink(),
+                        inputs_have_ltoir=False,
+                        lto_requested=False,
+                    )
+                    == "driver"
+                )
             except Exception as exc:
                 self._cached_decision = None
                 self._cached_decision_exc = exc
 
@@ -406,7 +406,7 @@ def test_make_program_cache_key_ptx_driver_ignored_fields_collapse(field, a, b,
     compiles differing only in these flags produce identical ObjectCode."""
     from cuda.core import _linker
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)  # driver
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "driver")
     k_a = _make_key(code=".version 7.0", code_type="ptx", options=_opts(**{field: a}))
     k_b = _make_key(code=".version 7.0", code_type="ptx", options=_opts(**{field: b}))
     assert k_a == k_b
@@ -430,7 +430,7 @@ def test_make_program_cache_key_ptx_ptxas_options_canonicalized(a, b, monkeypatc
     as equivalent so equivalent compiles don't miss the cache."""
     from cuda.core import _linker
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: False)  # nvJitLink
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "nvjitlink")
     k_a = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ptxas_options=a))
     k_b = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ptxas_options=b))
     assert k_a == k_b
@@ -440,7 +440,7 @@ def test_make_program_cache_key_ptx_driver_ignored_fields_still_matter_under_nvj
     """nvJitLink does honour those fields; they must still differentiate keys there."""
     from cuda.core import _linker
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: False)  # nvJitLink
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "nvjitlink")
     k_a = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ftz=True))
     k_b = _make_key(code=".version 7.0", code_type="ptx", options=_opts(ftz=False))
     assert k_a != k_b
@@ -600,7 +600,7 @@ def test_make_program_cache_key_ptx_rejects_driver_linker_unsupported(option_kw,
     to exactly mirror the driver-linker's own gate."""
     from cuda.core import _linker
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)  # driver
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "driver")
     with pytest.raises(ValueError, match="driver linker"):
         _make_key(code=".version 7.0", code_type="ptx", options=_opts(**option_kw))
 
@@ -610,7 +610,7 @@ def test_make_program_cache_key_ptx_accepts_driver_linker_unsupported_with_nvjit
     rejected at key time."""
     from cuda.core import _linker
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: False)  # nvJitLink
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "nvjitlink")
     # Should not raise.
     _make_key(code=".version 7.0", code_type="ptx", options=_opts(time=True))
 
@@ -1104,7 +1104,7 @@ def test_make_program_cache_key_driver_probe_failure_taints_ptx_under_cuLink(mon
     def _broken():
         raise RuntimeError("driver probe failed")
 
-    monkeypatch.setattr(_linker, "_decide_nvjitlink_or_driver", lambda: True)
+    monkeypatch.setattr(_linker, "_choose_backend", lambda *_args, **_kwargs: "driver")
     k_ok = _make_key(code=".ptx", code_type="ptx")
     monkeypatch.setattr(_program_cache._keys, "_driver_version", _broken)
     k_broken1 = _make_key(code=".ptx", code_type="ptx")