@@ -611,48 +611,97 @@ def test_user_object_cleanup_is_coalesced_on_python_thread(init_cuda):
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
-def test_pending_call_queue_saturation_preserves_cleanup(init_cuda):
+def test_pending_call_queue_saturation_preserves_cleanup(tmp_path):
     """A full CPython queue neither strands nor mis-threads cleanup."""
-    pending_callback_type = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p)
-    add_pending_call = ctypes.pythonapi.Py_AddPendingCall
-    add_pending_call.argtypes = [pending_callback_type, ctypes.c_void_p]
-    add_pending_call.restype = ctypes.c_int
+    code = f"timeout = {_FINALIZE_TIMEOUT!r}\n" + textwrap.dedent(
+        """
+        import ctypes
+        import gc
+        import threading
+        import time
+
+        from cuda.core import Device
+        from cuda.core.graph import GraphDefinition
 
-    @pending_callback_type
-    def noop_pending_call(_):
-        return 0
+        class ThreadRecordingCallback:
+            def __init__(self, finalized_threads):
+                self.finalized_threads = finalized_threads
 
-    finalized_threads = []
-    main_thread = threading.get_ident()
-    first_callback = _ThreadRecordingCallback(finalized_threads)
-    first_graph = GraphDefinition()
-    first_graph.callback(first_callback)
-    graph_holder = [first_graph]
-    worker_done = threading.Event()
-    queue_was_full = []
+            def __call__(self):
+                pass
+
+            def __del__(self):
+                self.finalized_threads.append(threading.get_ident())
+
+        def wait_until(predicate):
+            deadline = time.monotonic() + timeout
+            while True:
+                gc.collect()
+                if predicate():
+                    return
+                if time.monotonic() >= deadline:
+                    break
+                time.sleep(0)
+                time.sleep(0.02)
+            raise AssertionError(f"condition not satisfied within {timeout}s")
+
+        Device(0).set_current()
+
+        pending_callback_type = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p)
+        add_pending_call = ctypes.pythonapi.Py_AddPendingCall
+        add_pending_call.argtypes = [pending_callback_type, ctypes.c_void_p]
+        add_pending_call.restype = ctypes.c_int
+        make_pending_calls = ctypes.pythonapi.Py_MakePendingCalls
+        make_pending_calls.argtypes = []
+        make_pending_calls.restype = ctypes.c_int
+
+        @pending_callback_type
+        def noop_pending_call(_):
+            return 0
+
+        finalized_threads = []
+        main_thread = threading.get_ident()
+        first_callback = ThreadRecordingCallback(finalized_threads)
+        first_graph = GraphDefinition()
+        first_graph.callback(first_callback)
+        graph_holder = [first_graph]
+        worker_done = threading.Event()
+        queue_was_full = []
+
+        del first_callback, first_graph
+
+        def fill_queue_and_destroy():
+            while add_pending_call(noop_pending_call, None) == 0:
+                pass
+            queue_was_full.append(True)
+            graph_holder.clear()
+            worker_done.set()
 
-    del first_callback, first_graph
+        worker = threading.Thread(target=fill_queue_and_destroy)
+        worker.start()
+        assert worker_done.wait(timeout=5)
+        worker.join()
+        assert queue_was_full == [True]
 
-    def fill_queue_and_destroy():
-        while add_pending_call(noop_pending_call, None) == 0:
-            pass
-        queue_was_full.append(True)
-        graph_holder.clear()
-        worker_done.set()
-
-    worker = threading.Thread(target=fill_queue_and_destroy)
-    worker.start()
-    assert worker_done.wait(timeout=5)
-    worker.join()
-    assert queue_was_full == [True]
-
-    # A later safe cuda-core close retries after the main thread has had an
-    # opportunity to drain the foreign pending calls.
-    retry_builder = Device().create_graph_builder()
-    retry_builder.close()
-
-    _wait_until(lambda: len(finalized_threads) == 1)
-    assert set(finalized_threads) == {main_thread}
+        # Free space before the cuda-core entry that retries cleanup scheduling.
+        assert make_pending_calls() == 0
+
+        retry_builder = Device().create_graph_builder()
+        retry_builder.close()
+
+        wait_until(lambda: len(finalized_threads) == 1)
+        assert set(finalized_threads) == {main_thread}
+        """
+    )
+    result = subprocess.run(  # noqa: S603 - controlled interpreter probe
+        [sys.executable, "-c", code],
+        capture_output=True,
+        text=True,
+        timeout=60,
+        # Isolate the process-global pending-call queue from parallel tests.
+        cwd=tmp_path,
+    )
+    assert result.returncode == 0, result.stderr
 
 
 @pytest.mark.agent_authored(model="gpt-5.6")
 
@@ -5,7 +5,6 @@
 import time
 
 import pytest
-from helpers import IS_WINDOWS, IS_WSL
 from helpers.buffers import PatternGen, compare_equal_buffers, make_scratch_buffer
 from helpers.latch import LatchKernel
 from helpers.logging import TimestampedLogger
@@ -35,9 +34,9 @@ def test_latchkernel():
     target.copy_from(ones, stream=stream)
     log("going to sleep")
     time.sleep(1)
-    if not IS_WINDOWS and not IS_WSL:
-        # On any sort of Windows system, checking the memory before stream
-        # sync results in a page error.
+    if device.properties.concurrent_managed_access:
+        # Host access to managed memory while a kernel is active is unsafe on
+        # devices without concurrent managed access.
         log("checking target == 0")
         assert compare_equal_buffers(target, zeros)
     log("releasing latch and syncing")
 
@@ -38,6 +38,7 @@
 import ctypes
 import importlib
 import json
+import re
 import sys
 import sysconfig
 from io import StringIO
@@ -114,6 +115,9 @@ def _format_base_type_name(bt: object) -> str:
     if cls == "CComplexBaseTypeNode":
         inner = _format_base_type_name(bt.base_type)
         return _unwrap_declarator(inner, bt.declarator)[0]
+    if cls == "CConstOrVolatileTypeNode":
+        # Discard const/volatile qualifiers; they don't affect ABI layout
+        return _format_base_type_name(bt.base_type)
     return cls
 
 
@@ -263,6 +267,62 @@ def get_structs(module: object) -> dict:
     return dict(sorted(structs.items()))
 
 
+_OLD_ANON_RE = re.compile(r"^anon_(struct|union)\d+$")
+_NEW_ANON_RE = re.compile(r"^\w+__anon_pod\d+$")
+
+
+def _is_anon_name(name: str) -> bool:
+    return bool(_OLD_ANON_RE.match(name)) or bool(_NEW_ANON_RE.match(name))
+
+
+def _normalize_type(type_str: str, rename_map: dict) -> str:
+    """Replace old anon_struct/union names in a type string using rename_map."""
+    for old, new in rename_map.items():
+        # Use word-boundary matching so e.g. "anon_struct1" doesn't corrupt "anon_struct12"
+        type_str = re.sub(r"\b" + re.escape(old) + r"\b", new, type_str)
+    return type_str
+
+
+def _build_anon_rename_map(expected: dict, found: dict) -> dict:
+    """Match old anon_struct/union names to new MODULE__anon_pod names by field content.
+
+    Works iteratively bottom-up: leaf anon structs (whose fields contain no anon
+    type references) are matched first.  Their old->new mapping is then used to
+    normalize the field types of the remaining unmatched anon structs, which may
+    allow the next round to match parent structs that embed them.  Repeats until
+    no new matches are found in a round.
+    """
+    old_anons = {name: info for name, info in expected.items() if _is_anon_name(name)}
+    new_pods = {name: info for name, info in found.items() if _is_anon_name(name)}
+
+    rename_map = {}
+    matched_pods = set()
+    unmatched_old = dict(old_anons)
+
+    while True:
+        matched_this_round = {}
+
+        for old_name, old_info in unmatched_old.items():
+            # Normalize this struct's field types using mappings found so far
+            normalized_fields = [[_normalize_type(f[0], rename_map), f[1]] for f in old_info.get("fields", [])]
+            for new_name, new_info in new_pods.items():
+                if new_name in matched_pods:
+                    continue
+                if normalized_fields == new_info.get("fields", []):
+                    matched_this_round[old_name] = new_name
+                    matched_pods.add(new_name)
+                    break
+
+        if not matched_this_round:
+            break  # No progress; remaining old anons have no content-matching pod
+
+        rename_map.update(matched_this_round)
+        for name in matched_this_round:
+            del unmatched_old[name]
+
+    return rename_map
+
+
 def _report_field_changes(name: str, expected_fields: list, found_fields: list) -> None:
     """Print detailed field-level differences for a struct."""
     expected_dict = {f[1]: f[0] for f in expected_fields}
@@ -289,12 +349,22 @@ def check_structs(expected: dict, found: dict) -> tuple[bool, bool]:
     has_errors = False
     has_allowed_changes = False
 
+    rename_map = _build_anon_rename_map(expected, found)
+    renamed_new = set(rename_map.values())
+
     for name, expected_info in expected.items():
-        if name not in found:
+        effective_name = rename_map.get(name, name)
+
+        if effective_name not in found:
             print(f"  Missing struct/class: {name}")
             has_errors = True
             continue
-        found_info = found[name]
+
+        if effective_name != name:
+            # Anon struct/union renamed to new-style anon_pod — allowed change
+            has_allowed_changes = True
+
+        found_info = found[effective_name]
 
         if "basicsize" in expected_info:
             if "basicsize" not in found_info:
@@ -310,12 +380,15 @@ def check_structs(expected: dict, found: dict) -> tuple[bool, bool]:
             if "fields" not in found_info:
                 print(f"  Struct {name}: field information no longer available")
                 has_errors = True
-            elif found_info["fields"] != expected_info["fields"]:
-                _report_field_changes(name, expected_info["fields"], found_info["fields"])
-                has_errors = True
+            else:
+                # Normalize old anon type names in expected field types before comparing
+                normalized_fields = [[_normalize_type(f[0], rename_map), f[1]] for f in expected_info["fields"]]
+                if found_info["fields"] != normalized_fields:
+                    _report_field_changes(name, normalized_fields, found_info["fields"])
+                    has_errors = True
 
     for name in found:
-        if name not in expected:
+        if name not in expected and name not in renamed_new:
             print(f"  Added struct/class: {name}")
             has_allowed_changes = True
 
@@ -426,6 +499,9 @@ def generate(package: str, abi_dir: Path) -> bool:
 
     build_dir = get_package_path(package)
     for so_path in Path(build_dir).glob(f"**/*{EXT_SUFFIX}"):
+        if any(x.startswith("_") for x in so_path.parts):
+            # Skip private modules (e.g. _driver.so) since they are not part of the public ABI
+            continue
         try:
             module = import_from_path(package, build_dir, so_path)
         except ImportError: