@@ -11,8 +11,8 @@ name: "CI: Runner trust probe"
 
 on:
   schedule:
-    # Weekly on Mondays at 06:23 UTC
-    - cron: "23 6 * * 1"
+    # Daily at 06:00 PST (14:00 UTC)
+    - cron: "0 14 * * *"
   workflow_dispatch:
     inputs:
       label-filter:
 
@@ -90,7 +90,23 @@ in_container() {
 }
 
 host_install() {
-  apt-get -y install build-essential dkms "linux-headers-$(uname -r)" psmisc kmod
+  local kernel_release kernel_gcc default_gcc
+  kernel_release=$(uname -r)
+  apt-get -y install build-essential
+
+  # Match the kernel's GCC major only when the default compiler differs.
+  kernel_gcc=$(sed -nE 's/.*gcc(-[0-9]+)? (\([^)]*\) )?([0-9]+)\..*/\3/p' /proc/version)
+  default_gcc=$(gcc -dumpversion | cut -d. -f1)
+  echo "Kernel ${kernel_release}: GCC major=${kernel_gcc:-unknown}, default GCC major=${default_gcc}" >&2
+  if [ -n "$kernel_gcc" ] && [ "$kernel_gcc" != "$default_gcc" ]; then
+    apt-get -y install "gcc-${kernel_gcc}" "g++-${kernel_gcc}"
+    # Installing a versioned compiler does not change the default; select it for DKMS.
+    export CC="gcc-${kernel_gcc}" CXX="g++-${kernel_gcc}"
+    echo "Kernel ${kernel_release}: using CC=${CC} CXX=${CXX}" >&2
+  fi
+
+  # Header installation can trigger DKMS builds, so select the compiler first.
+  apt-get -y install dkms "linux-headers-${kernel_release}" psmisc kmod
 
   # Download and verify the installer before tearing down the existing
   # host driver so a download failure or SHA-256 mismatch leaves the
 
@@ -48,9 +48,9 @@ module.exports = async function runNodeTrustProbe({
 
   const tlsResult = await probeEndpoint();
   const rows = [
-    ['Node version', versionOk ? '**PASS**' : '**FAIL**', `\`${version}\` (require Node 24 \`>= v24.22.1\`; \`execPath=${execPath}\`)`],
-    ['Node env overrides', '**INFO**', `\`NODE_OPTIONS=${nodeOptions}\`, \`NODE_EXTRA_CA_CERTS=${extraCa}\`, \`NODE_USE_SYSTEM_CA=${useSystemCa}\``],
-    ['Node rejects test endpoint', `**${tlsResult.status}**`, tlsResult.detail],
+    ['Node version', versionOk ? '<strong>PASS</strong>' : '<strong>FAIL</strong>', `\`${version}\` (require Node 24 \`>= v24.22.1\`; \`execPath=${execPath}\`)`],
+    ['Node env overrides', '<strong>INFO</strong>', `\`NODE_OPTIONS=${nodeOptions}\`, \`NODE_EXTRA_CA_CERTS=${extraCa}\`, \`NODE_USE_SYSTEM_CA=${useSystemCa}\``],
+    ['Node rejects test endpoint', `<strong>${tlsResult.status}</strong>`, tlsResult.detail],
   ];
 
   await core.summary
 
@@ -14,7 +14,7 @@
 import pytest
 from helpers.graph_kernels import compile_common_kernels
 
-from cuda.core import Device, DeviceMemoryResource, LaunchConfig, LegacyPinnedMemoryResource
+from cuda.core import Device, DeviceMemoryResource, EventOptions, LaunchConfig, LegacyPinnedMemoryResource
 from cuda.core._memory._synchronous_memory_resource import _SynchronousMemoryResource
 from cuda.core._utils._weak_handles import weak_handle
 from cuda.core._utils.cuda_utils import CUDAError, driver, handle_return
@@ -96,36 +96,27 @@ def _update_executable_case(graph, case):
 
 
 def _event_record_case(device):
-    """Keep the selected event pending to identify each exec's record target."""
-    original = device.create_event()
-    replacement = device.create_event()
-    invalid_replacement = device.create_event()
+    """Identify each exec's record target after completion."""
+    event_options = EventOptions(timing_enabled=True)
+    original = device.create_event(options=event_options)
+    replacement = device.create_event(options=event_options)
+    invalid_replacement = device.create_event(options=event_options)
     invalid_replacement.close()
 
-    callback_started = threading.Event()
-    callback_release = threading.Event()
-
-    def blocking_callback():
-        callback_started.set()
-        callback_release.wait(timeout=30)
-
     graph_def = GraphDefinition()
-    callback_node = graph_def.callback(blocking_callback)
-    node = callback_node.record(original)
+    node = graph_def.record(original)
 
     def assert_exec_uses(graph, expected):
-        callback_started.clear()
-        callback_release.clear()
         stream = device.create_stream()
+        reference = stream.record(options=event_options)
+        stream.sync()
+
+        with pytest.raises(RuntimeError, match=r"^Both Events must be recorded"):
+            expected - reference
+
         graph.launch(stream)
-        try:
-            assert callback_started.wait(timeout=5)
-            assert expected.is_done is False
-            unexpected = replacement if expected is original else original
-            assert unexpected.is_done is True
-        finally:
-            callback_release.set()
-            stream.sync()
+        stream.sync()
+        assert isinstance(expected - reference, float)
 
     return _DefinitionUpdateCase(
         graph_def=graph_def,