@@ -66,8 +66,10 @@ void clear_last_error() noexcept;
 
 extern decltype(&cuDevicePrimaryCtxRetain) p_cuDevicePrimaryCtxRetain;
 extern decltype(&cuDevicePrimaryCtxRelease) p_cuDevicePrimaryCtxRelease;
+extern decltype(&cuDevicePrimaryCtxGetState) p_cuDevicePrimaryCtxGetState;
 extern decltype(&cuCtxGetCurrent) p_cuCtxGetCurrent;
 extern decltype(&cuCtxSetCurrent) p_cuCtxSetCurrent;
+extern decltype(&cuCtxGetDevice) p_cuCtxGetDevice;
 extern decltype(&cuGreenCtxCreate) p_cuGreenCtxCreate;
 extern decltype(&cuGreenCtxDestroy) p_cuGreenCtxDestroy;
 extern decltype(&cuCtxFromGreenCtx) p_cuCtxFromGreenCtx;
@@ -232,7 +234,16 @@ GreenCtxHandle create_green_ctx_handle_ref(CUgreenCtx ctx);
 // Returns empty handle on error (caller must check)
 ContextHandle get_primary_context(int device_id);
 
-// Get handle to the current CUDA context
+// Create a context handle that owns `ctx` when the driver allows it.
+// cuDevicePrimaryCtxRetain is the only lifetime-extending context API, so an
+// owning handle is returned only for a device's primary context (or for a
+// context cuda.core already tracks). Otherwise this degrades to
+// create_context_handle_ref and the caller must keep the context alive.
+// Returns empty handle if ctx is null.
+ContextHandle retain_context_handle(CUcontext ctx);
+
+// Get handle to the current CUDA context, owning it when possible
+// (see retain_context_handle).
 // Returns empty handle if no context is current (caller must check)
 ContextHandle get_current_context();
 
@@ -354,12 +365,16 @@ using DevicePtrHandle = std::shared_ptr<const CUdeviceptr>;
 DevicePtrHandle deviceptr_alloc_from_pool(
     size_t size,
     const MemoryPoolHandle& h_pool,
-    const StreamHandle& h_stream);
+    const StreamHandle& h_stream,
+    const ContextHandle& h_release_context);
 
 // Allocate device memory asynchronously via cuMemAllocAsync.
 // When the last reference is released, cuMemFreeAsync is called on the stored stream.
 // Returns empty handle on error (caller must check).
-DevicePtrHandle deviceptr_alloc_async(size_t size, const StreamHandle& h_stream);
+DevicePtrHandle deviceptr_alloc_async(
+    size_t size,
+    const StreamHandle& h_stream,
+    const ContextHandle& h_release_context);
 
 // Allocate device memory synchronously via cuMemAlloc.
 // When the last reference is released, cuMemFree is called.
@@ -390,7 +405,8 @@ DevicePtrHandle deviceptr_create_with_owner(CUdeviceptr ptr, PyObject* owner);
 DevicePtrHandle deviceptr_create_mapped_graphics(
     CUdeviceptr ptr,
     const GraphicsResourceHandle& h_resource,
-    const StreamHandle& h_stream);
+    const StreamHandle& h_stream,
+    const ContextHandle& h_release_context);
 
 // Callback type for MemoryResource deallocation.
 // Called from the shared_ptr deleter when a handle created via
@@ -404,36 +420,39 @@ using MRDeallocCallback = void (*)(PyObject* mr, CUdeviceptr ptr,
 void register_mr_dealloc_callback(MRDeallocCallback cb);
 
 // Create a device pointer handle whose destructor calls mr.deallocate()
-// via the registered callback. The supplied allocation context is retained,
-// and the optional deallocation stream is passed to the callback. The mr's
-// refcount is incremented and decremented when the handle is released.
+// via the registered callback. The supplied allocation context becomes a
+// dependency of the handle. h_stream is passed to the callback unchanged, and
+// h_release_context is made current while the callback runs. The mr's refcount
+// is incremented and decremented when the handle is released.
 // If mr is nullptr, equivalent to deviceptr_create_ref.
 DevicePtrHandle deviceptr_create_with_mr(
     CUdeviceptr ptr,
     size_t size,
     PyObject* mr,
     const ContextHandle& h_allocation_context,
     const StreamHandle& h_stream,
-    bool require_stream_context);
+    const ContextHandle& h_release_context);
 
 // Import a device pointer from IPC via cuMemPoolImportPointer.
 // When the last reference is released, cuMemFreeAsync is called on the stored stream.
+// h_release_context is made current for that call.
 // Note: Does not yet implement reference counting for nvbug 5570902.
 // On error, returns empty handle and sets thread-local error (use get_last_error()).
 DevicePtrHandle deviceptr_import_ipc(
     const MemoryPoolHandle& h_pool,
     const void* export_data,
-    const StreamHandle& h_stream);
+    const StreamHandle& h_stream,
+    const ContextHandle& h_release_context);
 
 // Access the deallocation stream for a device pointer handle (read-only).
 // For non-owning handles, the stream is not used but can still be accessed.
 StreamHandle deallocation_stream(const DevicePtrHandle& h) noexcept;
 
-// Set the deallocation stream for a device pointer handle. Context-relative
-// default streams are bound to the calling thread's current context.
-CUresult set_deallocation_stream(
+// Set the stream and context to use when the device pointer is released.
+void set_deallocation_stream(
     const DevicePtrHandle& h,
-    const StreamHandle& h_stream) noexcept;
+    const StreamHandle& h_stream,
+    const ContextHandle& h_release_context) noexcept;
 
 // ============================================================================
 // Library handle functions
 
@@ -8,6 +8,7 @@ from typing import Sequence
 
 from cuda.bindings cimport cydriver
 from cuda.core._resource_handles cimport (
+    ContextHandle,
     DevicePtrHandle,
     create_graphics_resource_handle,
     deviceptr_create_mapped_graphics,
@@ -16,7 +17,11 @@ from cuda.core._resource_handles cimport (
     as_intptr,
 )
 from cuda.core._memory._buffer cimport Buffer, Buffer_from_deviceptr_handle
-from cuda.core._stream cimport Stream, Stream_accept
+from cuda.core._stream cimport (
+    Stream,
+    Stream_accept,
+    Stream_resolve_context,
+)
 from cuda.core._utils.cuda_utils cimport HANDLE_RETURN
 
 __all__ = ['GraphicsResource']
@@ -281,6 +286,9 @@ cdef class GraphicsResource:
         cdef Stream s_obj = Stream_accept(stream)
         cdef cydriver.CUgraphicsResource raw = as_cu(self._handle)
         cdef cydriver.CUstream cy_stream = as_cu(s_obj._h_stream)
+        cdef ContextHandle h_release_context = Stream_resolve_context(s_obj)
+        if not h_release_context:
+            HANDLE_RETURN(cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT)
         try:
             with nogil:
                 HANDLE_RETURN(
@@ -300,7 +308,11 @@ cdef class GraphicsResource:
                 HANDLE_RETURN(rollback_status)
             raise
         h_ptr = deviceptr_create_mapped_graphics(
-            dev_ptr, self._handle, s_obj._h_stream)
+            dev_ptr,
+            self._handle,
+            s_obj._h_stream,
+            h_release_context,
+        )
         if not h_ptr:
             status = get_last_error()
             with nogil:
 
@@ -45,6 +45,10 @@ class Buffer:
         When ``mr`` is provided, the buffer takes ownership: ``mr.deallocate()``
         is called when the buffer is closed or garbage collected.  When ``owner``
         is provided, the owner is kept alive but no deallocation is performed.
+
+        An owning buffer always records a deallocation stream, defaulting to
+        ``default_stream()``, so teardown never has to choose one at destruction
+        time. Callers wanting different ordering must pass ``stream``.
         """
 
     @staticmethod
@@ -73,9 +77,11 @@ class Buffer:
             The reference is kept as long as the buffer is alive.
             The ``owner`` and ``mr`` cannot be specified together.
         stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`, optional
-            Initial deallocation stream when ``mr`` owns the pointer. If
-            omitted, the current default stream is selected and retained now,
-            rather than during eventual destruction.
+            Deallocation stream to record when ``mr`` owns the pointer.
+            Defaults to the calling thread's default stream, chosen here
+            rather than at destruction time. Note that a default stream is
+            recorded as a token: under per-thread default streams the driver
+            resolves it against whichever thread runs the destructor.
 
         Note
         ----
 
@@ -17,7 +17,7 @@ from cuda.core._resource_handles cimport (
     ContextHandle,
     DevicePtrHandle,
     StreamHandle,
-    create_context_handle_ref,
+    retain_context_handle,
     deviceptr_create_with_owner,
     deviceptr_create_with_mr,
     get_last_error,
@@ -28,7 +28,12 @@ from cuda.core._resource_handles cimport (
 )
 from cuda.core.typing import DevicePointerType
 
-from cuda.core._stream cimport Stream, Stream_accept, default_stream
+from cuda.core._stream cimport (
+    Stream,
+    Stream_accept,
+    Stream_resolve_context,
+    default_stream,
+)
 from cuda.core._utils.cuda_utils cimport HANDLE_RETURN, _parse_fill_value
 
 import sys
@@ -55,10 +60,19 @@ cdef void _mr_dealloc_callback(
     """Called by the C++ deleter to deallocate via MemoryResource.deallocate.
 
     This is the C++ teardown path: there is no Python caller frame from
-    which to obtain a stream. The device-pointer handle therefore carries
-    the exact stream selected at allocation/adoption or by ``Buffer.close``.
-    An empty handle remains ``None``; cleanup must never invent ordering by
-    selecting a default stream at destruction time.
+    which to obtain a stream, so the handle supplies the stream recorded at
+    allocation/adoption or by ``Buffer.close`` and cleanup never picks one of
+    its own. An empty handle stays ``None``, which is a warning-only path: a
+    resource that cannot free without a stream raises, and the failure is
+    reported below rather than propagated, because a destructor has nowhere to
+    raise to.
+
+    The recorded stream may be a default-stream token. A token is resolved by
+    the driver on the thread that runs the destructor, so under per-thread
+    default streams the physical stream can differ from the one the buffer's
+    owner used. Only the choice of stream is preserved; ordering work across
+    threads remains the application's responsibility, as it is for the
+    equivalent raw driver calls.
     """
     cdef object stream
     try:
@@ -76,13 +90,18 @@ __all__ = ['Buffer', 'MemoryResource']
 
 cdef ContextHandle _pointer_context_handle(
     cydriver.CUdeviceptr ptr,
-    bint* require_stream_context,
+    bint* is_stream_ordered,
 ):
-    """Return the pointer's owning context when CUDA reports one."""
+    """Return a handle for the pointer's owning context, if CUDA reports one.
+
+    The handle owns the context when the driver permits it (see
+    ``retain_context_handle``), which for a primary context makes the
+    allocation's context a genuine dependency of the buffer.
+    """
     cdef ContextHandle h_context
     cdef cydriver.CUcontext context = NULL
     cdef cydriver.CUresult result
-    require_stream_context[0] = False
+    is_stream_ordered[0] = False
     if ptr == 0:
         return h_context
 
@@ -94,9 +113,9 @@ cdef ContextHandle _pointer_context_handle(
         )
     if result == cydriver.CUDA_SUCCESS:
         if context != NULL:
-            return create_context_handle_ref(context)
+            return retain_context_handle(context)
         # Stream-ordered allocations are context-independent.
-        require_stream_context[0] = True
+        is_stream_ordered[0] = True
         return h_context
     if result in (
         cydriver.CUresult.CUDA_ERROR_INVALID_VALUE,
@@ -216,28 +235,38 @@ cdef class Buffer:
         When ``mr`` is provided, the buffer takes ownership: ``mr.deallocate()``
         is called when the buffer is closed or garbage collected.  When ``owner``
         is provided, the owner is kept alive but no deallocation is performed.
+
+        An owning buffer always records a deallocation stream, defaulting to
+        ``default_stream()``, so teardown never has to choose one at destruction
+        time. Callers wanting different ordering must pass ``stream``.
         """
         if mr is not None and owner is not None:
             raise ValueError("owner and memory resource cannot be both specified together")
         cdef Buffer self = Buffer.__new__(cls)
         cdef uintptr_t c_ptr = <uintptr_t>(int(ptr))
-        cdef ContextHandle h_context
+        cdef ContextHandle h_allocation_context
+        cdef ContextHandle h_release_context
         cdef StreamHandle h_stream
         cdef Stream s
-        cdef bint require_stream_context
+        cdef bint is_stream_ordered
         if mr is not None:
-            if stream is not None:
-                s = Stream_accept(stream)
-                h_stream = s._h_stream
-            h_context = _pointer_context_handle(
-                c_ptr, &require_stream_context)
+            s = Stream_accept(default_stream() if stream is None else stream)
+            h_stream = s._h_stream
+            h_allocation_context = _pointer_context_handle(
+                c_ptr, &is_stream_ordered)
+            h_release_context = Stream_resolve_context(s)
+            if not h_release_context:
+                h_release_context = h_allocation_context
+            if is_stream_ordered and not h_release_context:
+                HANDLE_RETURN(
+                    cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT)
             self._h_ptr = deviceptr_create_with_mr(
                 c_ptr,
                 size,
                 mr,
-                h_context,
+                h_allocation_context,
                 h_stream,
-                require_stream_context,
+                h_release_context,
             )
             if not self._h_ptr:
                 HANDLE_RETURN(get_last_error())
@@ -289,18 +318,18 @@ cdef class Buffer:
             The reference is kept as long as the buffer is alive.
             The ``owner`` and ``mr`` cannot be specified together.
         stream : :obj:`~_stream.Stream` | :obj:`~graph.GraphBuilder`, optional
-            Initial deallocation stream when ``mr`` owns the pointer. If
-            omitted, the current default stream is selected and retained now,
-            rather than during eventual destruction.
+            Deallocation stream to record when ``mr`` owns the pointer.
+            Defaults to the calling thread's default stream, chosen here
+            rather than at destruction time. Note that a default stream is
+            recorded as a token: under per-thread default streams the driver
+            resolves it against whichever thread runs the destructor.
 
         Note
         ----
         When neither ``mr`` nor ``owner`` is specified, this creates a
         non-owning reference.  The pointer will NOT be freed when the
         :class:`Buffer` is closed or garbage collected.
         """
-        if mr is not None and stream is None:
-            stream = default_stream()
         return Buffer._init(
             ptr, size, mr=mr, owner=owner, stream=stream)
 
@@ -680,14 +709,19 @@ cdef Buffer Buffer_from_deviceptr_handle(
 cdef inline void Buffer_close(Buffer self, object stream):
     """Close a buffer, freeing its memory."""
     cdef Stream s
+    cdef ContextHandle h_release_context
     if not self._h_ptr:
         return
     # Update deallocation stream if provided
     if stream is not None:
         s = Stream_accept(stream)
+        h_release_context = Stream_resolve_context(s)
+        if not h_release_context:
+            HANDLE_RETURN(
+                cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT)
         with nogil:
-            HANDLE_RETURN(set_deallocation_stream(
-                self._h_ptr, s._h_stream))
+            set_deallocation_stream(
+                self._h_ptr, s._h_stream, h_release_context)
     # Reset handle - RAII deleter will free the memory (and release owner ref in C++)
     self._h_ptr.reset()
     self._size = 0
 
@@ -9,13 +9,18 @@ from libc.stdint cimport intptr_t
 from cuda.bindings cimport cydriver
 from cuda.core._memory._buffer cimport Buffer, Buffer_from_deviceptr_handle, MemoryResource
 from cuda.core._resource_handles cimport (
+    ContextHandle,
     DevicePtrHandle,
     deviceptr_alloc_async,
     get_last_error,
     as_cu,
 )
 
-from cuda.core._stream cimport Stream_accept, Stream
+from cuda.core._stream cimport (
+    Stream,
+    Stream_accept,
+    Stream_resolve_context,
+)
 from cuda.core._utils.cuda_utils cimport HANDLE_RETURN
 
 from typing import TYPE_CHECKING
@@ -210,10 +215,14 @@ cdef inline int check_capturing(cydriver.CUstream s) except?-1 nogil:
 
 cdef inline Buffer GMR_allocate(cyGraphMemoryResource self, size_t size, Stream stream):
     cdef cydriver.CUstream s = as_cu(stream._h_stream)
+    cdef ContextHandle h_release_context = Stream_resolve_context(stream)
+    if not h_release_context:
+        HANDLE_RETURN(cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT)
     cdef DevicePtrHandle h_ptr
     with nogil:
         check_capturing(s)
-        h_ptr = deviceptr_alloc_async(size, stream._h_stream)
+        h_ptr = deviceptr_alloc_async(
+            size, stream._h_stream, h_release_context)
     if not h_ptr:
         HANDLE_RETURN(get_last_error())
         raise RuntimeError(