feat(cccl): integrate missing CCCL directories — python/, ci/, .agent/, docs/, test/

Sparse-checkout from NVIDIA/cccl main branch to complete cccl_upstream:

Added:
- python/cuda_cccl/ (226 files) — Python bindings for device-level algorithms
  Critical for muh toolchain: cuda.compute.reduce_into, scan, radix_sort, etc.
  Includes 204 .py files with full test coverage for all 27 algorithms
- ci/ (163 files) — Build/test infrastructure
  build_cub.sh, test_cub.sh, build_and_test_targets.sh, matrix.yaml
  Directly maps to our [INFRA-CI] and [INFRA-BUILD] items
- .agent/skills/ (7 files) — NVIDIA's own agent skills for CCCL
  cccl-style/SKILL.md, cccl-test/SKILL.md, sass-diff/SKILL.md
- docs/ (491 files) — Official CCCL documentation
  CI references, CMake guides, Python compute docs, libcudacxx PTX docs
- test/ (12 files) — Top-level integration tests (cuda_smoke, stdpar)
- Root configs: .clang-format, .clang-tidy, CONTRIBUTING.md, pyproject.toml
- CLAUDE.md symlink → AGENTS.md (NVIDIA's standard)

cccl_upstream now mirrors full NVIDIA/cccl structure:
  Before: 42M (cub + thrust + libcudacxx + cudax + c + examples + benchmarks)
  After:  53M (+python +ci +docs +.agent +test +configs)

This completes the CCCL base needed for:
- [muh-bench] items: ci/util/build_and_test_targets.sh for targeted builds
- [CCCL-verify] items: python/cuda_cccl/tests/ as reference implementations
- [CCCL-test] items: ci/test_cub.sh, ci/test_thrust.sh
- Agent workflow: .agent/skills/ for consistent style and test patterns

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/bit.rst

@@ -0,0 +1,47 @@
+.. _libcudacxx-standard-api-numerics-bit:
+
+``<cuda/std/bit>``
+==================
+
+``cuda::std::bit_cast``
+-----------------------
+
+``cuda::std::bit_cast`` extended the standard ``std::bit_cast`` to also recognize CUDA extended floating-point scalar and vector types as trivially copyable.
+
+**Limitations**
+
+- The function can be used in ``constexpr`` contexts only when the source and destination types are trivially copyable.
+- The function cannot be used in ``constexpr`` contexts with MSVC <= 19.25 and GCC <= 10.
+
+CUDA Performance Considerations
+-------------------------------
+
+Given an unsigned integer with ``N`` bits and ``N <= 32``, the ``<bit>`` functions translate into the following SASS instructions. For some functions, the results is decorated with a compile-time assumption to restrict its range and allowing further optimizations.
+
+- ``bit_width()`` translates into a single ``FLO`` SASS instruction. The result is assumed to be in the range ``[0, N]``.
+- ``bit_ceil()`` translates into ``ADD, FLO, SHL, IMINMAX`` SASS instructions. The result is assumed to be greater than or equal to the input.
+- ``bit_floor()`` translates into ``FLO, SHL`` SASS instructions. The result is assumed to be less than or equal to the input.
+- ``byteswap()`` translates into a single ``PRMT`` SASS instruction.
+- ``popcount()`` translates into a single ``POPC`` SASS instruction. The result is assumed to be in the range ``[0, N]``.
+- ``has_single_bit()`` translates into ``POPC + ISETP`` SASS instructions.
+- ``rotl()/rotr()`` translate into a single ``SHF`` (funned shift) SASS instruction.
+- ``countl_zero()`` translates into ``FLO, IMINMAX`` SASS instructions. The result is assumed to be in the range ``[0, N]``.
+- ``countl_one()`` translates into ``LOP3, FLO, IMINMAX`` SASS instructions. The result is assumed to be in the range ``[0, N]``.
+- ``countr_zero()`` translates into ``BREV, FLO, IMINMAX`` SASS instructions. The result is assumed to be in the range ``[0, N]``.
+- ``countr_one()`` translates into ``LOP3, BREV, FLO, IMINMAX`` SASS instructions. The result is assumed to be in the range ``[0, N]``.
+
+Additional Notes
+----------------
+
+- All functions are marked ``[[nodiscard]]`` and ``noexcept``
+- All functions support 128-bit integer types
+- ``bit_ceil()`` checks for overflow in debug mode
+- ``rotl()/rotr()`` checks for invalid count value (``INT_MIN``) in debug mode
+
+.. note::
+
+    When the input values are run-time values that the compiler can resolve at compile-time, e.g. an index of a loop with a fixed number of iterations, using the functions could not be optimal.
+
+.. note::
+
+    GCC <= 8 uses a slow path with more instructions even in CUDA

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/complex.rst

@@ -0,0 +1,41 @@
+.. _libcudacxx-standard-api-numerics-complex:
+
+``<cuda/std/complex>``
+======================
+
+Omissions
+---------
+
+  When using libcu++ with NVCC, ``complex`` does not support ``long double`` or ``complex`` literals (``_i``, ``_if``, and ``_il``).
+  NVCC warns on any usage of ``long double`` in device code, because ``long double`` will be demoted to ``double`` in device code.
+  This warning can be suppressed silenced with ``#pragma``\ s, but only globally, not just when using ``complex``.
+  User-defined floating-point literals must be specified in terms of ``long double``, so they lead to warnings
+  that are unable to be suppressed.
+
+Extensions
+--------------
+
+- Handling of infinities
+
+  Our implementation by default recovers infinite values during multiplication and division. This adds a significant runtime overhead,
+  so we allow disabling that canonicalization if it is not desired.
+
+  Definition of ``LIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS`` disables canonicalization for both multiplication *and* division.
+
+  Definition of ``LIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_MULTIPLICATION`` or ``LIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_DIVISION`` disables
+  canonicalization for multiplication or division individually.
+
+- Support for half and bfloat16 (since libcu++ 2.4.0)
+
+  Our implementation includes support for the ``__half`` type from ``<cuda_fp16.h>``, when the CUDA toolkit version is at
+  least 12.2, and when ``CCCL_DISABLE_FP16_SUPPORT`` is **not** defined.
+
+  This is detected automatically when compiling through NVCC. If you are compiling a host-only translation unit directly
+  with the host compiler, you must define the macro ``LIBCUDACXX_ENABLE_HOST_NVFP16`` prior to including any libcu++ headers,
+  and you must ensure that the ``<cuda_fp16.h>`` header that's found by the compiler comes from a CUDA toolkit version
+  12.2 or higher.
+
+  Our implementation includes support for the ``__nv_bfloat16`` type from ``<cuda_bf16.h>``, when the conditions for the
+  support of ``__half`` are fulfilled, and when ``CCCL_DISABLE_BF16_SUPPORT`` and ``CCCL_DISABLE_FP16_SUPPORT`` are **not** defined.
+
+- C++20 constexpr ``<complex>`` is available in C++14.

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/linalg.rst

@@ -0,0 +1,31 @@
+.. _libcudacxx-standard-api-numerics-linalg:
+
+``<cuda/std/linalg>``
+============================================
+
+Provided functionalities
+------------------------
+
+- ``scaled()`` `std::linalg::scaled <https://en.cppreference.com/w/cpp/numeric/linalg/scaled>`_
+- ``scaled_accessor`` `std::linalg::scaled_accessor <https://en.cppreference.com/w/cpp/numeric/linalg/scaled_accessor>`_
+- ``conjugated()`` `std::linalg::conjugated <https://en.cppreference.com/w/cpp/numeric/linalg/conjugated>`_
+- ``conjugated_accessor`` `std::linalg::conjugated_accessor <https://en.cppreference.com/w/cpp/numeric/linalg/conjugated_accessor>`_
+- ``transposed()`` `std::linalg::transposed <https://en.cppreference.com/w/cpp/numeric/linalg/transposed>`_
+- ``layout_transpose`` `std::linalg::layout_transpose <https://en.cppreference.com/w/cpp/numeric/linalg/layout_transpose>`_
+- ``conjugate_transposed()`` `std::linalg::conjugate_transposed <https://en.cppreference.com/w/cpp/numeric/linalg/conjugate_transposed>`_
+
+Extensions
+----------
+
+-  C++26 ``std::linalg`` accessors, transposed layout, and related functions are available in C++17
+
+Omissions
+---------
+
+-  Currently we do not expose any BLAS functions and layouts.
+
+Restrictions
+------------
+
+-  On device no exceptions are thrown in case of a bad access.
+-  MSVC is only supported with C++20

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/numbers.rst

@@ -0,0 +1,10 @@
+.. _libcudacxx-standard-api-numerics-numbers:
+
+``<cuda/std/numbers>``
+======================
+
+Extensions
+----------
+
+-  All features of ``<numbers>`` are made available in C++14 onwards
+-  Implementation is provided only on Linux systems due to NVCC's lack of template ``const __device__`` variables support

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/numeric.rst

@@ -0,0 +1,41 @@
+.. _libcudacxx-standard-api-numerics-numeric:
+
+``<cuda/std/numeric>``
+======================
+
+Omissions
+---------
+
+-  Currently we do not expose any parallel algorithms.
+
+Extensions
+----------
+
+-  All features of ``<numeric>`` are made available in C++11 onwards
+-  All features of ``<numeric>`` are made constexpr in C++14 onwards
+-  Algorithms that return a value and not an iterator have been marked ``[[nodiscard]]``
+
+
+Parallel standard algorithms
+----------------------------
+
+CCCL provides an implementation for the standard `parallel algorithms library <http://www.eel.is/c++draft/algorithms.parallel>`_
+
+Currently the CUDA backend is the only supported backend. It can be selected by passing the `cuda::execution::gpu`
+execution policy to one of the supported algorithms. The CUDA backend requires the passed in sequences to reside in
+device accessible memory and the iterators into those sequences to be at least random access iterators. The CUDA backend
+is enabled if the program is compiled with a CUDA compiler in CUDA mode.
+
+The use of any other execution policy is currently not supported and results in a compile time error.
+
+The following algorithms are supported:
+
+  * ``adjacent_difference``
+  * ``exclusive_scan``
+  * ``inclusive_scan``
+  * ``transform_exclusive_scan``
+  * ``transform_inclusive_scan``
+  * ``reduce``
+  * ``transform_reduce``
+
+The current implementation status is tracked in this `GitHub Issue <https://github.com/NVIDIA/cccl/issues/5592>`_

cccl_upstream/docs/libcudacxx/standard_api/numerics_library/random.rst

@@ -0,0 +1,72 @@
+.. _libcudacxx-standard-api-numerics-random:
+
+``<cuda/std/random>``
+=====================
+
+Provided functionalities
+------------------------
+
+Random number engines:
+
+- `cuda::std::minstd_rand0 <https://en.cppreference.com/w/cpp/numeric/random/minstd_rand0>`_
+- `cuda::std::minstd_rand <https://en.cppreference.com/w/cpp/numeric/random/minstd_rand>`_
+- C++26 `cuda::std::philox4x32 <https://en.cppreference.com/w/cpp/numeric/random/philox_engine.html>`_ - available from C++17 onwards
+- C++26 `cuda::std::philox4x64 <https://en.cppreference.com/w/cpp/numeric/random/philox_engine.html>`_ - available from C++17 onwards
+
+.. note::
+
+    ``cuda::pcg64`` is provided in the non-standard ``<cuda/random>`` header. See
+    :ref:`cuda::pcg64 <libcudacxx-extended-api-random-pcg64>`.
+
+Random number distributions:
+
+- `cuda::std::bernoulli_distribution <https://en.cppreference.com/w/cpp/numeric/random/bernoulli_distribution>`_
+- `cuda::std::binomial_distribution <https://en.cppreference.com/w/cpp/numeric/random/binomial_distribution>`_
+- `cuda::std::cauchy_distribution <https://en.cppreference.com/w/cpp/numeric/random/cauchy_distribution>`_
+- `cuda::std::chi_squared_distribution <https://en.cppreference.com/w/cpp/numeric/random/chi_squared_distribution>`_
+- `cuda::std::exponential_distribution <https://en.cppreference.com/w/cpp/numeric/random/exponential_distribution>`_
+- `cuda::std::extreme_value_distribution <https://en.cppreference.com/w/cpp/numeric/random/extreme_value_distribution>`_
+- `cuda::std::fisher_f_distribution <https://en.cppreference.com/w/cpp/numeric/random/fisher_f_distribution>`_
+- `cuda::std::gamma_distribution <https://en.cppreference.com/w/cpp/numeric/random/gamma_distribution>`_
+- `cuda::std::geometric_distribution <https://en.cppreference.com/w/cpp/numeric/random/geometric_distribution>`_
+- `cuda::std::lognormal_distribution <https://en.cppreference.com/w/cpp/numeric/random/lognormal_distribution>`_
+- `cuda::std::negative_binomial_distribution <https://en.cppreference.com/w/cpp/numeric/random/negative_binomial_distribution>`_
+- `cuda::std::normal_distribution <https://en.cppreference.com/w/cpp/numeric/random/normal_distribution>`_
+- `cuda::std::poisson_distribution <https://en.cppreference.com/w/cpp/numeric/random/poisson_distribution>`_
+- `cuda::std::student_t_distribution <https://en.cppreference.com/w/cpp/numeric/random/student_t_distribution>`_
+- `cuda::std::uniform_int_distribution <https://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution>`_
+- `cuda::std::uniform_real_distribution <https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution>`_
+- `cuda::std::weibull_distribution <https://en.cppreference.com/w/cpp/numeric/random/weibull_distribution>`_
+
+Utilities:
+
+- `cuda::std::seed_seq <https://en.cppreference.com/w/cpp/numeric/random/seed_seq>`_
+- `cuda::std::generate_canonical <https://en.cppreference.com/w/cpp/numeric/random/generate_canonical>`_
+
+
+.. note::
+
+    ``cuda::std::seed_seq`` should be used exclusively on host or exclusively on device. Do not share the same
+    ``seed_seq`` instance between host and device code.
+
+
+The following engines or distributions are not implemented as they are not convenient or practical to implement in CUDA device code, either due to dynamic memory allocations or large state sizes.
+
+Not supported
+-------------
+- `std::random_device <https://en.cppreference.com/w/cpp/numeric/random/random_device>`_
+- `std::mersenne_twister_engine <https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine>`_
+  (`std::mt19937 <https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine>`_,
+  `std::mt19937_64 <https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine>`_)
+- `std::subtract_with_carry_engine <https://en.cppreference.com/w/cpp/numeric/random/subtract_with_carry_engine.html>`_
+  (`std::ranlux24_base <https://en.cppreference.com/w/cpp/numeric/random/subtract_with_carry_engine.html>`_,
+  `std::ranlux48_base <https://en.cppreference.com/w/cpp/numeric/random/subtract_with_carry_engine.html>`_,
+  `std::ranlux24 <https://en.cppreference.com/w/cpp/numeric/random/subtract_with_carry_engine.html>`_,
+  `std::ranlux48 <https://en.cppreference.com/w/cpp/numeric/random/subtract_with_carry_engine.html>`_)
+- `std::discard_block_engine <https://en.cppreference.com/w/cpp/numeric/random/discard_block_engine.html>`_
+- `std::independent_bits_engine <https://en.cppreference.com/w/cpp/numeric/random/independent_bits_engine.html>`_
+- `std::shuffle_order_engine <https://en.cppreference.com/w/cpp/numeric/random/shuffle_order_engine>`_
+  (`std::knuth_b <https://en.cppreference.com/w/cpp/numeric/random/shuffle_order_engine>`_)
+- `std::discrete_distribution <https://en.cppreference.com/w/cpp/numeric/random/discrete_distribution.html>`_
+- `std::piecewise_constant_distribution <https://en.cppreference.com/w/cpp/numeric/random/piecewise_constant_distribution.html>`_
+- `std::piecewise_linear_distribution <https://en.cppreference.com/w/cpp/numeric/random/piecewise_linear_distribution.html>`_