@@ -12,6 +12,7 @@
 #include <BS_thread_pool.hpp>
 
 #include <cstddef>
+#include <future>
 #include <memory>
 
 namespace cudf::detail {
@@ -106,6 +107,41 @@ class CUDF_EXPORT hierarchical_thread_pool {
   [[nodiscard]] std::size_t get_thread_count() const { return pool_.get_thread_count(); }
 };
 
+/**
+ * @brief RAII guard that waits on all valid futures in `futures` upon destruction
+ *
+ * Futures returned by `hierarchical_thread_pool::submit_task` do not block on destruction. This
+ * guard waits for all of them without retrieving their results, so exceptions stored by the tasks
+ * are discarded and any in-flight exception propagates unchanged.
+ *
+ * @note Construct the guard after the futures container and after every object the tasks reference.
+ *
+ * @tparam Container Container of `std::future` objects
+ */
+template <typename Container>
+class futures_wait_guard {
+ public:
+  /**
+   * @brief Construct a guard over a container of futures.
+   *
+   * @param futures Futures to wait on when the guard is destroyed
+   */
+  explicit futures_wait_guard(Container& futures) noexcept : futures_{futures} {}
+
+  futures_wait_guard(futures_wait_guard const&)            = delete;
+  futures_wait_guard& operator=(futures_wait_guard const&) = delete;
+
+  ~futures_wait_guard() noexcept
+  {
+    for (auto& future : futures_) {
+      if (future.valid()) { future.wait(); }
+    }
+  }
+
+ private:
+  Container& futures_;
+};
+
 /**
  * @brief Retrieves the appropriate thread pool based on the calling thread's context.
  *
 
@@ -332,6 +332,7 @@ void host_compress(compression_type compression,
   auto h_results = cudf::detail::make_pinned_vector<codec_exec_result>(results, stream);
 
   std::vector<std::future<std::pair<size_t, size_t>>> tasks;
+  cudf::detail::futures_wait_guard tasks_guard{tasks};
   auto const num_streams =
     std::min<std::size_t>(num_chunks, cudf::detail::host_worker_pool().get_thread_count());
   auto const streams = cudf::detail::fork_streams(stream, num_streams);
 
@@ -571,6 +571,7 @@ void host_decompress(compression_type compression,
   stream.sync();
 
   std::vector<std::future<size_t>> tasks;
+  cudf::detail::futures_wait_guard tasks_guard{tasks};
   auto const num_streams =
     std::min<std::size_t>(num_chunks, cudf::detail::host_worker_pool().get_thread_count());
   auto const streams = cudf::detail::fork_streams(stream, num_streams);
 
@@ -12,6 +12,7 @@
 #include <cudf/detail/utilities/buffer_factories.hpp>
 #include <cudf/detail/utilities/cuda_memcpy.hpp>
 #include <cudf/detail/utilities/getenv_or.hpp>
+#include <cudf/detail/utilities/host_worker_pool.hpp>
 #include <cudf/detail/utilities/integer_utils.hpp>
 #include <cudf/detail/utilities/stream_pool.hpp>
 #include <cudf/detail/utilities/vector_factories.hpp>
@@ -754,6 +755,7 @@ device_span<char> ingest_raw_input(device_span<char> buffer,
   // delimiter.
   auto constexpr num_delimiter_chars = 1;
   std::vector<std::future<std::size_t>> thread_tasks;
+  cudf::detail::futures_wait_guard thread_tasks_guard{thread_tasks};
 
   auto delimiter_map = cudf::detail::make_empty_host_vector<std::size_t>(sources.size(), stream);
   std::vector<std::size_t> prefsum_source_sizes(sources.size());
@@ -861,6 +863,7 @@ table_with_metadata read_json_dispatch(host_span<std::unique_ptr<datasource>> so
 
   std::vector<std::unique_ptr<datasource>> compressed_sources;
   std::vector<std::future<std::unique_ptr<compressed_host_buffer_source>>> thread_tasks;
+  cudf::detail::futures_wait_guard thread_tasks_guard{thread_tasks};
   auto& thread_pool = pools::tpool();
   for (auto& src : sources) {
     thread_tasks.emplace_back(thread_pool.submit_task([&reader_opts, &src] {
 
@@ -21,6 +21,7 @@
 #include <cudf/detail/utilities/buffer_factories.hpp>
 #include <cudf/detail/utilities/cuda.cuh>
 #include <cudf/detail/utilities/cuda_memcpy.hpp>
+#include <cudf/detail/utilities/host_worker_pool.hpp>
 #include <cudf/detail/utilities/integer_utils.hpp>
 #include <cudf/detail/utilities/stream_pool.hpp>
 #include <cudf/detail/utilities/vector_factories.hpp>
@@ -2893,6 +2894,7 @@ void writer::impl::write_orc_data_to_sink(encoded_data const& enc_data,
 
   // Write stripes
   std::vector<std::future<void>> write_tasks;
+  cudf::detail::futures_wait_guard write_tasks_guard{write_tasks};
   for (size_t stripe_id = 0; stripe_id < stripes.size(); ++stripe_id) {
     auto& stripe = stripes[stripe_id];
 
 
@@ -14,7 +14,6 @@
 #include <algorithm>
 #include <cmath>
 #include <cstddef>
-#include <exception>
 #include <functional>
 #include <future>
 #include <optional>
@@ -482,66 +481,53 @@ class parquet_field_struct_list : public parquet_field {
       auto const items_per_task = n / num_tasks;
       auto const remainder      = n % num_tasks;
 
-      std::vector<std::future<void>> tasks;
-      tasks.reserve(num_tasks);
-
       // Size once up front, then fill by index below: workers read already-filled slots while the
       // main thread fills later ones, so a size-mutating emplace_back would be a data race.
       std::vector<cudf::host_span<uint8_t const>> all_ranges;
       all_ranges.resize(n);
 
-      // Wait for every task before all_ranges/val die on any exit path: a throw during collection
-      // must not let a worker read freed memory (host-pool futures do not block on destruction).
-      try {
-        uint32_t struct_idx = 0;
-        for (uint32_t task_id = 0; task_id < num_tasks; ++task_id) {
-          auto const task_size = items_per_task + (task_id < remainder ? 1 : 0);
-          auto const start_idx = std::min(n, struct_idx);
-          auto const end_idx   = std::min(n, start_idx + task_size);
-
-          if (start_idx >= end_idx) { break; }
-
-          // Collect struct ranges for the next task
-          for (auto i = start_idx; i < end_idx; ++i) {
-            uint8_t const* const start = cpr->m_cur;
-            cpr->skip_struct_field(static_cast<int>(FieldType::STRUCT));
-            all_ranges[i] =
-              cudf::host_span<uint8_t const>{start, static_cast<size_t>(cpr->m_cur - start)};
-          }
+      // Declared after all_ranges so that every task is waited on before all_ranges dies on any
+      // exit path (host-pool futures do not block on destruction)
+      std::vector<std::future<void>> tasks;
+      cudf::detail::futures_wait_guard tasks_guard{tasks};
+      tasks.reserve(num_tasks);
 
-          // Launch task immediately to parse the structs in parallel while the main thread collects
-          // the remaining ranges
-          tasks.emplace_back(cudf::detail::host_worker_pool().submit_task(
-            [&val = this->val, &all_ranges, start_idx, end_idx, mode]() {
-              CompactProtocolReader local_cpr{nullptr, 0, mode};
-              // end_idx alone bounds the loop: all_ranges[start_idx, end_idx) is fully populated
-              // before this task launches, so no concurrent read of all_ranges.size() is needed.
-              for (size_t i = start_idx; i < end_idx; ++i) {
-                local_cpr.init(all_ranges[i].data(), all_ranges[i].size());
-                local_cpr.read(&val[i]);
-              }
-            }));
-
-          struct_idx = end_idx;
-        }
-      } catch (...) {
-        for (auto& task : tasks) {
-          task.wait();
+      uint32_t struct_idx = 0;
+      for (uint32_t task_id = 0; task_id < num_tasks; ++task_id) {
+        auto const task_size = items_per_task + (task_id < remainder ? 1 : 0);
+        auto const start_idx = std::min(n, struct_idx);
+        auto const end_idx   = std::min(n, start_idx + task_size);
+
+        if (start_idx >= end_idx) { break; }
+
+        // Collect struct ranges for the next task
+        for (auto i = start_idx; i < end_idx; ++i) {
+          uint8_t const* const start = cpr->m_cur;
+          cpr->skip_struct_field(static_cast<int>(FieldType::STRUCT));
+          all_ranges[i] =
+            cudf::host_span<uint8_t const>{start, static_cast<size_t>(cpr->m_cur - start)};
         }
-        throw;
+
+        // Launch task immediately to parse the structs in parallel while the main thread collects
+        // the remaining ranges
+        tasks.emplace_back(cudf::detail::host_worker_pool().submit_task(
+          [&val = this->val, &all_ranges, start_idx, end_idx, mode]() {
+            CompactProtocolReader local_cpr{nullptr, 0, mode};
+            // end_idx alone bounds the loop: all_ranges[start_idx, end_idx) is fully populated
+            // before this task launches, so no concurrent read of all_ranges.size() is needed.
+            for (size_t i = start_idx; i < end_idx; ++i) {
+              local_cpr.init(all_ranges[i].data(), all_ranges[i].size());
+              local_cpr.read(&val[i]);
+            }
+          }));
+
+        struct_idx = end_idx;
       }
-      // Join EVERY task before leaving, then rethrow the first failure: task.get() throws on a
-      // strict-mode mismatch, and bailing out of this loop mid-way would abandon the remaining
-      // un-joined tasks, whose lambdas still reference all_ranges/val (use-after-free at exit).
-      std::exception_ptr first_error;
+      // Rethrows the first failure (e.g. a strict-mode mismatch); the guard waits for the
+      // remaining tasks, whose lambdas reference all_ranges/val, while unwinding
       for (auto& task : tasks) {
-        try {
-          task.get();
-        } catch (...) {
-          if (!first_error) { first_error = std::current_exception(); }
-        }
+        task.get();
       }
-      if (first_error) { std::rethrow_exception(first_error); }
     } else {
       // For small numbers of elements, use sequential processing to avoid overhead
       std::for_each(val.begin(), val.end(), [&cpr](auto& elem) { cpr->read(&elem); });
 
@@ -389,10 +389,11 @@ thrust::host_vector<bool> aggregate_reader_metadata::compute_data_page_mask(
     // task submission overheads
     auto constexpr max_tasks         = 2;
     using task_page_row_offsets_type = std::vector<std::pair<std::vector<size_type>, size_type>>;
-    std::vector<std::future<task_page_row_offsets_type>> page_row_offset_tasks{};
-    page_row_offset_tasks.reserve(max_tasks);
     auto const cols_per_thread =
       cudf::detail::div_rounding_up_safe<std::size_t>(num_columns, max_tasks);
+    std::vector<std::future<task_page_row_offsets_type>> page_row_offset_tasks{};
+    cudf::detail::futures_wait_guard page_row_offset_tasks_guard{page_row_offset_tasks};
+    page_row_offset_tasks.reserve(max_tasks);
 
     // Submit page row offset compute tasks
     std::transform(cuda::counting_iterator<int>{0},
 
@@ -106,6 +106,7 @@ auto dispatch_tasks(std::size_t num_tasks, Task task)
   } else {
     // Dispatch the tasks to the host worker pool
     std::vector<std::future<result_type>> futures;
+    cudf::detail::futures_wait_guard futures_guard{futures};
     futures.reserve(num_tasks);
     std::for_each(cuda::counting_iterator<std::size_t>(0),
                   cuda::counting_iterator<std::size_t>(num_tasks),
@@ -237,6 +238,7 @@ void read_ranges_to_host(std::span<std::reference_wrapper<cudf::io::datasource>
                          bool serialize_submissions)
 {
   std::vector<std::future<std::size_t>> host_read_tasks;
+  cudf::detail::futures_wait_guard host_read_tasks_guard{host_read_tasks};
   std::vector<std::size_t> expected_sizes;
   host_read_tasks.reserve(count);
   expected_sizes.reserve(count);
@@ -383,7 +385,9 @@ fetch_byte_ranges_to_device_async_impl(
 
   // Vectors to hold futures from datasource
   std::vector<std::future<size_t>> device_read_tasks{};
+  cudf::detail::futures_wait_guard device_read_tasks_guard{device_read_tasks};
   std::vector<std::future<host_read_buffer>> host_read_tasks{};
+  cudf::detail::futures_wait_guard host_read_tasks_guard{host_read_tasks};
   device_read_tasks.reserve(io_offsets.size());
   host_read_tasks.reserve(io_offsets.size());
 
@@ -468,6 +472,7 @@ fetch_byte_ranges_to_device_async_impl(
   if (not host_buffers.empty()) { stream.sync(); }
 
   auto sync_function = [](decltype(device_read_tasks) device_read_tasks) {
+    cudf::detail::futures_wait_guard device_read_tasks_guard{device_read_tasks};
     for (auto& task : device_read_tasks) {
       task.get();
     }
 
@@ -645,6 +645,7 @@ void metadata::setup_page_index(std::span<uint8_t const> page_index_bytes, int64
     auto const remainder              = total_column_chunks % num_tasks;
 
     std::vector<std::future<void>> tasks;
+    cudf::detail::futures_wait_guard tasks_guard{tasks};
     tasks.reserve(num_tasks);
 
     std::size_t start_idx = 0;
 
@@ -19,7 +19,6 @@
 #include <thrust/host_vector.h>
 
 #include <algorithm>
-#include <exception>
 #include <functional>
 #include <future>
 #include <memory>
@@ -64,28 +63,19 @@ template <typename T, typename UnaryOp>
   }
 
   std::vector<std::future<result_type>> tasks;
+  cudf::detail::futures_wait_guard tasks_guard{tasks};
   tasks.reserve(inputs.size());
 
-  auto pending_exception = std::exception_ptr{};
-  try {
-    std::transform(inputs.begin(), inputs.end(), std::back_inserter(tasks), [&op](T const& input) {
-      return cudf::detail::host_worker_pool().submit_task(
-        [&op, input_ptr = &input] { return op(*input_ptr); });
-    });
-  } catch (...) {
-    pending_exception = std::current_exception();
-  }
+  std::transform(inputs.begin(), inputs.end(), std::back_inserter(tasks), [&op](T const& input) {
+    return cudf::detail::host_worker_pool().submit_task(
+      [&op, input_ptr = &input] { return op(*input_ptr); });
+  });
 
+  // Rethrows the first task failure; the guard waits for the remaining tasks on unwinding
   for (auto& task : tasks) {
-    try {
-      results.emplace_back(task.get());
-    } catch (...) {
-      if (not pending_exception) { pending_exception = std::current_exception(); }
-    }
+    results.emplace_back(task.get());
   }
 
-  if (pending_exception) { std::rethrow_exception(pending_exception); }
-
   return results;
 }