diff --git a/.github/scripts/ci_sgpu_jobs.conf b/.github/scripts/ci_sgpu_jobs.conf
new file mode 100644
index 000000000..fe75cf3ad
--- /dev/null
+++ b/.github/scripts/ci_sgpu_jobs.conf
@@ -0,0 +1,8 @@
+# sGPU job definitions for CI test suites.
+# Format: <label>  <logfile>  <command> [args...]
+# GPUs are assigned sequentially by run_parallel_sgpu.sh starting from --first-gpu.
+
+examples  examples.log  .github/scripts/run_examples.sh
+torch     torch.log     ci/pytorch.sh
+jax       jax.log       ci/jax.sh
+core      core.log      ci/core.sh
diff --git a/.github/scripts/run_examples.sh b/.github/scripts/run_examples.sh
new file mode 100755
index 000000000..5c83d3833
--- /dev/null
+++ b/.github/scripts/run_examples.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/bash
+# Copyright (c) 2024-2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+#
+# Run TE examples on a single GPU.
+# HIP_VISIBLE_DEVICES must be set by the caller (run_parallel_sgpu.sh).
+
+set -e
+
+# Autodetect repo root from this script's location (.github/scripts/ -> ../..)
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+python -c "import os; print('HF_TOKEN set:', bool(os.environ.get('HF_TOKEN')))"
+
+JAX_CONSTRAINTS=/tmp/jax-constraints.txt
+pip freeze | grep -iE '^(jax|jaxlib|jax[_-]rocm|jax[_-]plugins)[=@]' > "$JAX_CONSTRAINTS" || true
+
+cd "${REPO_ROOT}/examples/pytorch/mnist"
+python main.py
+python main.py --use-te
+python main.py --use-fp8
+
+cd "${REPO_ROOT}/examples/jax/mnist"
+pip3 install -c "$JAX_CONSTRAINTS" -r requirements.txt
+python test_single_gpu_mnist.py
+python test_single_gpu_mnist.py --use-te
+python test_single_gpu_mnist.py --use-fp8
+
+cd "${REPO_ROOT}/examples/jax/encoder"
+pip3 install -c "$JAX_CONSTRAINTS" -r requirements.txt
+python test_single_gpu_encoder.py
+python test_single_gpu_encoder.py --use-fp8
diff --git a/.github/scripts/run_parallel_sgpu.sh b/.github/scripts/run_parallel_sgpu.sh
new file mode 100755
index 000000000..6e275273a
--- /dev/null
+++ b/.github/scripts/run_parallel_sgpu.sh
@@ -0,0 +1,167 @@
+#!/bin/bash
+# Copyright (c) 2024-2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+#
+# Run multiple sGPU jobs in parallel from one or more config files.
+#
+# Usage: run_parallel_sgpu.sh [-g|--first-gpu <n>] [-l|--log-dir <dir>] <config>...
+#
+# Config format (one job per line; # comments and blank lines are ignored):
+#   <label>  <logfile>  <command> [args...]
+#
+# GPUs are assigned sequentially starting from --first-gpu across all config
+# entries in the order configs are passed on the command line.
+#
+# Each job's exit code is written to <log-dir>/<logfile>.rc by the job runner.
+
+# Resolve repo root relative to this script's location (.github/scripts/ -> ../..)
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+# How often (seconds) to poll child processes
+: "${POLL_INTERVAL:=5}"
+# Warn if a log file has not been updated in this many seconds
+: "${STALL_WARN_SECS:=180}"
+# Number of tail lines to show for stalled logs
+: "${STALL_TAIL_LINES:=15}"
+
+# Associative arrays:  _JOB_PIDS[name]=pid   _JOB_LOGS[pid]=logfile
+declare -A _JOB_PIDS
+declare -A _JOB_LOGS
+_OVERALL_RC=0
+
+# Launch a background job and register it.
+# Usage: launch_job <name> <logfile> <cmd> [args...]
+launch_job() {
+    local name="$1"
+    local logfile="$2"
+    local rcfile="${logfile}.rc"
+    shift 2
+    rm -f "$rcfile"
+    "$@" >"$logfile" 2>&1 &
+    local pid=$!
+    _JOB_PIDS["$name"]=$pid
+    _JOB_LOGS[$pid]="$logfile"
+    echo "Started '${name}' (pid ${pid}) -> ${logfile}"
+}
+
+# Wait for all currently registered jobs, polling every POLL_INTERVAL seconds.
+# Writes <logfile>.rc for every finished job; warns about stalled logs.
+# Clears _JOB_PIDS/_JOB_LOGS when done.
+wait_for_jobs() {
+    local -A remaining
+    local -A stall_mtime
+    for name in "${!_JOB_PIDS[@]}"; do
+        remaining["$name"]="${_JOB_PIDS[$name]}"
+    done
+
+    while [ ${#remaining[@]} -gt 0 ]; do
+        sleep "$POLL_INTERVAL"
+
+        for name in "${!remaining[@]}"; do
+            local pid="${remaining[$name]}"
+
+            if ! kill -0 "$pid" 2>/dev/null; then
+                # Process has exited — capture its return code
+                wait "$pid"
+                local rc=$?
+                echo "[$(date '+%Y-%m-%d %H:%M:%S')] '${name}' (pid ${pid}) finished with rc=${rc}"
+                if [ $rc -ne 0 ]; then
+                    _OVERALL_RC=$rc
+                fi
+                echo "$rc" > "${_JOB_LOGS[$pid]}.rc"
+                unset "remaining[$name]"
+            else
+                # Process still running — check for log staleness
+                local logfile="${_JOB_LOGS[$pid]}"
+                if [ -f "$logfile" ]; then
+                    local now mtime age
+                    now=$(date +%s)
+                    mtime=$(stat -c '%Y' "$logfile" 2>/dev/null || echo "$now")
+                    age=$(( now - mtime ))
+                    if [ -n "${stall_mtime[$pid]+set}" ]; then
+                        if [ "$mtime" -gt "${stall_mtime[$pid]}" ]; then
+                            echo "[$(date '+%Y-%m-%d %H:%M:%S')] INFO: '${name}' (pid ${pid}) log '${logfile}' resumed updating (was frozen)"
+                            unset "stall_mtime[$pid]"
+                        fi
+                        # else: still stalled but already warned — do nothing
+                    elif [ "$age" -ge "$STALL_WARN_SECS" ]; then
+                        echo "[$(date '+%Y-%m-%d %H:%M:%S')] WARNING: '${name}' (pid ${pid}) log '${logfile}' has not been updated for ${age}s"
+                        echo "--- last ${STALL_TAIL_LINES} lines of ${logfile} ---"
+                        tail -n "$STALL_TAIL_LINES" "$logfile"
+                        echo "--- end of ${logfile} ---"
+                        stall_mtime[$pid]=$mtime
+                    fi
+                fi
+            fi
+        done
+    done
+
+    # Reset for next batch
+    unset _JOB_PIDS
+    unset _JOB_LOGS
+    declare -gA _JOB_PIDS
+    declare -gA _JOB_LOGS
+}
+
+FIRST_GPU=${TEST_FIRST_GPU:-0}
+LOG_DIR=${LOG_DIR:-/tmp/te_ci_logs}
+
+# ---------------------------------------------------------------------------
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        -g|--first-gpu)
+            FIRST_GPU="$2"; shift 2 ;;
+        --first-gpu=*)
+            FIRST_GPU="${1#*=}"; shift ;;
+        -l|--log-dir)
+            LOG_DIR="$2"; shift 2 ;;
+        --log-dir=*)
+            LOG_DIR="${1#*=}"; shift ;;
+        -*)
+            echo "Unknown option: $1" >&2
+            echo "Usage: $0 [-g|--first-gpu <n>] [-l|--log-dir <dir>] <config>..." >&2
+            exit 1 ;;
+        *)
+            break ;;
+    esac
+done
+
+if [[ $# -eq 0 ]]; then
+    echo "Error: at least one config file is required." >&2
+    echo "Usage: $0 [-g|--first-gpu <n>] [-l|--log-dir <dir>] <config>..." >&2
+    exit 1
+fi
+
+# Resolve config paths and LOG_DIR to absolute against the caller's CWD
+# *before* changing directory, so relative paths passed by the caller remain valid.
+resolved_configs=()
+for c in "$@"; do
+    resolved_configs+=( "$(realpath -m "$c")" )
+done
+[[ "$LOG_DIR" != /* ]] && LOG_DIR="$(realpath -m "$LOG_DIR")"
+
+mkdir -p "$LOG_DIR"
+
+# cd to repo root so that commands in configs (e.g. ci/pytorch.sh) resolve correctly
+cd "$REPO_ROOT" || { echo "Error: cannot cd to '${REPO_ROOT}'" >&2; exit 1; }
+
+# ---------------------------------------------------------------------------
+# Launch all jobs, assigning GPUs sequentially across all config files
+gpu=$FIRST_GPU
+for config in "${resolved_configs[@]}"; do
+    while IFS= read -r line || [[ -n "$line" ]]; do
+        # Skip blank lines and comments
+        [[ "$line" =~ ^[[:space:]]*# ]] && continue
+        [[ -z "${line//[[:space:]]/}" ]]  && continue
+        read -r label logfile rest <<< "$line"
+        # shellcheck disable=SC2086  # $rest is intentionally word-split
+        HIP_VISIBLE_DEVICES=$gpu launch_job "$label" "${LOG_DIR}/$logfile" $rest
+        (( gpu++ ))
+    done < "$config"
+done
+
+wait_for_jobs
+exit $_OVERALL_RC
diff --git a/.github/workflows/rocm-ci.yml b/.github/workflows/rocm-ci.yml
index e2fb09c15..b347111d7 100644
--- a/.github/workflows/rocm-ci.yml
+++ b/.github/workflows/rocm-ci.yml
@@ -144,15 +144,28 @@ jobs:
 
       - name: Run Container
         run: |
+          # All GPUs are visible to the runner; per-suite visibility is set later
+          # via HIP_VISIBLE_DEVICES in the test step. Add render group for the
+          # container. Under kubernetes, GPU isolation comes from DEVICE_FLAG:
+          # the runner writes this pod's allocated render devices into
+          # /etc/podinfo/gha-render-devices; fall back to all GPUs on bare metal.
+          render_gid=$(cat /etc/group | grep render | cut -d: -f3)
+          if [ -f "/etc/podinfo/gha-render-devices" ]; then
+            DEVICE_FLAG=$(cat /etc/podinfo/gha-render-devices)
+          else
+            DEVICE_FLAG="--device /dev/dri"
+          fi
+          # --group-add daemon/bin cover the video-group GID -> subgid 1 mapping
+          # across Ubuntu 24.04 / AlmaLinux base images. /dev/kfd is the single
+          # system-wide compute node and is always required.
+          GPU_FLAG="--device=/dev/mem --device=/dev/kfd $DEVICE_FLAG --group-add video --group-add $render_gid --group-add daemon --group-add bin --cap-add=SYS_PTRACE --security-opt seccomp=unconfined"
           docker run -dt \
             --rm \
             --name te-runner \
             --network=host \
-            --device=/dev/dri --device=/dev/kfd \
+            $GPU_FLAG \
             --shm-size=16G \
             --pid=host \
-            --group-add $(getent group render | cut -d: -f3) \
-            --group-add $(getent group video | cut -d: -f3) \
             -v "${{ github.workspace }}:/workspace" \
             -w /workspace \
             ${{ needs.select_image.outputs.image-tag }}
@@ -182,114 +195,45 @@ jobs:
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
         run: |
-          rm -f FAIL_*
+          rm -rf test-results && mkdir -p test-results
 
           docker exec \
             -e TEST_SGPU=1 \
             -e TEST_LEVEL=${{ env.TEST_LEVEL }} \
+            -e JUNITXML_PREFIX=/workspace/test-results/ \
+            -e JUNITXML_SUFFIX=.xml \
             -e HF_TOKEN="$HF_TOKEN" \
-            te-runner bash -c "$(cat <<'EOF'
-          #!/usr/bin/bash
-          set -x -o pipefail
-          ulimit -c 0 # Disable core dumps
-
-          HIP_VISIBLE_DEVICES=0 ci/pytorch.sh > /workspace/torch.log 2>&1 &
-          TORCH_PID=$!
-
-          HIP_VISIBLE_DEVICES=1 ci/jax.sh > /workspace/jax.log 2>&1 &
-          JAX_PID=$!
-
-          (
-            set -e
-            python -c "import os; print('HF_TOKEN set:', bool(os.environ.get('HF_TOKEN')))"
-
-            JAX_CONSTRAINTS=/tmp/jax-constraints.txt
-            pip freeze | grep -iE '^(jax|jaxlib|jax[_-]rocm|jax[_-]plugins)[=@]' > "$JAX_CONSTRAINTS" || true
-
-            export HIP_VISIBLE_DEVICES=2
-
-            cd /workspace/examples/pytorch/mnist
-            python main.py
-            python main.py --use-te
-            python main.py --use-fp8
-
-            cd /workspace/examples/jax/mnist
-            pip3 install -c "$JAX_CONSTRAINTS" -r requirements.txt
-            python test_single_gpu_mnist.py
-            python test_single_gpu_mnist.py --use-te
-            python test_single_gpu_mnist.py --use-fp8
-
-            cd /workspace/examples/jax/encoder
-            pip3 install -c "$JAX_CONSTRAINTS" -r requirements.txt
-            python test_single_gpu_encoder.py
-            python test_single_gpu_encoder.py --use-fp8
-          ) > /workspace/examples.log 2>&1 &
-          EXAMPLES_PID=$!
-
-          HIP_VISIBLE_DEVICES=3 ci/core.sh > /workspace/core.log 2>&1 &
-          CORE_PID=$!
-
-          wait $TORCH_PID;    torch_rc=$?
-          wait $JAX_PID;      jax_rc=$?
-          wait $EXAMPLES_PID; examples_rc=$?
-          wait $CORE_PID;     core_rc=$?
-
-          if [ $torch_rc -ne 0 ]; then
-            echo "::group::[FAILED] PyTorch Log"
-            cat /workspace/torch.log
-            echo "::endgroup::"
-            echo "::error::PyTorch tests FAILED."
-            touch /workspace/FAIL_TORCH
-          fi
-
-          if [ $jax_rc -ne 0 ]; then
-            echo "::group::[FAILED] JAX Log"
-            cat /workspace/jax.log
-            echo "::endgroup::"
-            echo "::error::JAX tests FAILED."
-            touch /workspace/FAIL_JAX
-          fi
-
-          if [ $examples_rc -ne 0 ]; then
-            echo "::group::[FAILED] Examples Log"
-            cat /workspace/examples.log
-            echo "::endgroup::"
-            echo "::error::Examples FAILED."
-            touch /workspace/FAIL_EXAMPLES
-          fi
+            te-runner bash /workspace/.github/scripts/run_parallel_sgpu.sh \
+              --first-gpu 0 \
+              --log-dir /workspace/ \
+              /workspace/.github/scripts/ci_sgpu_jobs.conf
 
-          if [ $core_rc -ne 0 ]; then
-            echo "::group::[FAILED] Core Log"
-            cat /workspace/core.log
-            echo "::endgroup::"
-            echo "::error::Core tests FAILED."
-            touch /workspace/FAIL_CORE
-          fi
-
-          test $torch_rc -eq 0 -a $jax_rc -eq 0 -a $examples_rc -eq 0 -a $core_rc -eq 0
-          EOF
-          )"
+      - name: Generate test report
+        if: always()
+        run: |
+          command -v python3 >/dev/null 2>&1 || { echo "python3 not available; skipping report"; exit 0; }
+          python3 ci/junit_report.py test-results \
+            --title "sGPU Tests (${{ matrix.arch_label }})"
 
       - name: Check suite failure status
         if: always()
         run: |
           EXIT_STATUS=0
-          if [[ -f FAIL_TORCH ]]; then
-            echo "::error::PyTorch tests failed."
-            EXIT_STATUS=1
-          fi
-          if [[ -f FAIL_JAX ]]; then
-            echo "::error::JAX tests failed."
-            EXIT_STATUS=1
-          fi
-          if [[ -f FAIL_EXAMPLES ]]; then
-            echo "::error::Examples failed."
-            EXIT_STATUS=1
-          fi
-          if [[ -f FAIL_CORE ]]; then
-            echo "::error::Core tests failed."
-            EXIT_STATUS=1
-          fi
+          for config in .github/scripts/ci_sgpu_jobs.conf; do
+            while IFS= read -r line || [[ -n "$line" ]]; do
+              [[ "$line" =~ ^[[:space:]]*# ]] && continue
+              [[ -z "${line//[[:space:]]/}" ]] && continue
+              read -r label logfile rest <<< "$line"
+              rc=$(cat "${logfile}.rc" 2>/dev/null || echo "missing")
+              if [[ "$rc" != "0" ]]; then
+                echo "::group::[FAILED] ${label} Log (rc=${rc})"
+                cat "$logfile" 2>/dev/null || echo "(log not found)"
+                echo "::endgroup::"
+                echo "::error::${label} tests FAILED."
+                EXIT_STATUS=1
+              fi
+            done < "$config"
+          done
           exit $EXIT_STATUS
 
       - name: Upload logs
@@ -299,6 +243,7 @@ jobs:
           name: logs-sgpu-${{ matrix.arch_label }}
           path: |
             *.log
+            test-results/*.xml
           if-no-files-found: ignore
           retention-days: 5
 
@@ -341,15 +286,28 @@ jobs:
 
       - name: Run Container
         run: |
+          # All GPUs are visible to the runner; per-suite visibility is set later
+          # via HIP_VISIBLE_DEVICES in the test step. Add render group for the
+          # container. Under kubernetes, GPU isolation comes from DEVICE_FLAG:
+          # the runner writes this pod's allocated render devices into
+          # /etc/podinfo/gha-render-devices; fall back to all GPUs on bare metal.
+          render_gid=$(cat /etc/group | grep render | cut -d: -f3)
+          if [ -f "/etc/podinfo/gha-render-devices" ]; then
+            DEVICE_FLAG=$(cat /etc/podinfo/gha-render-devices)
+          else
+            DEVICE_FLAG="--device /dev/dri"
+          fi
+          # --group-add daemon/bin cover the video-group GID -> subgid 1 mapping
+          # across Ubuntu 24.04 / AlmaLinux base images. /dev/kfd is the single
+          # system-wide compute node and is always required.
+          GPU_FLAG="--device=/dev/mem --device=/dev/kfd $DEVICE_FLAG --group-add video --group-add $render_gid --group-add daemon --group-add bin --cap-add=SYS_PTRACE --security-opt seccomp=unconfined"
           docker run -dt \
             --rm \
             --name te-runner \
             --network=host \
-            --device=/dev/dri --device=/dev/kfd \
+            $GPU_FLAG \
             --shm-size=16G \
             --pid=host \
-            --group-add $(getent group render | cut -d: -f3) \
-            --group-add $(getent group video | cut -d: -f3) \
             -v "${{ github.workspace }}:/workspace" \
             -w /workspace \
             ${{ needs.select_image.outputs.image-tag }}
@@ -387,6 +345,8 @@ jobs:
             *)       echo "::error::Unknown framework: ${{ matrix.framework }}"; exit 1 ;;
           esac
 
+          rm -rf test-results && mkdir -p test-results
+
           docker exec \
             -e TEST_MGPU=1 \
             -e TEST_LEVEL=${{ env.TEST_LEVEL }} \
@@ -394,6 +354,8 @@ jobs:
             -e LOG_FILE=$LOG_FILE \
             -e SUITE_NAME=$SUITE_NAME \
             -e NVTE_FRAMEWORK=${{ matrix.framework }} \
+            -e JUNITXML_PREFIX=/workspace/test-results/ \
+            -e JUNITXML_SUFFIX=.xml \
             -e HF_TOKEN="$HF_TOKEN" \
             te-runner bash -c "$(cat <<'EOF'
           #!/usr/bin/bash
@@ -414,6 +376,13 @@ jobs:
           EOF
           )"
 
+      - name: Generate test report
+        if: always()
+        run: |
+          command -v python3 >/dev/null 2>&1 || { echo "python3 not available; skipping report"; exit 0; }
+          python3 ci/junit_report.py test-results \
+            --title "mGPU ${{ matrix.framework == 'pytorch' && 'Torch' || 'JAX' }} (${{ matrix.arch_label }})"
+
       - name: Upload logs
         if: always()
         uses: actions/upload-artifact@v4
@@ -421,6 +390,7 @@ jobs:
           name: logs-mgpu-${{ matrix.arch_label }}-${{ matrix.framework }}
           path: |
             *.log
+            test-results/*.xml
           if-no-files-found: ignore
           retention-days: 5
 
diff --git a/ci/_utils.sh b/ci/_utils.sh
index 9c0f4a847..87659477c 100644
--- a/ci/_utils.sh
+++ b/ci/_utils.sh
@@ -23,6 +23,17 @@ TEST_START_TS=`date +%s`
 #To disable some logs trimming
 export CI=1
 
+# Crash/hang visibility and bounding:
+# - PYTHONFAULTHANDLER dumps a Python traceback on fatal signals (segfaults).
+# - PYTEST_TIMEOUT bounds every individual test item so a single hang cannot
+#   stall the whole CI job; the offending test is recorded as a failure with a
+#   traceback instead of the run silently timing out hours later.
+# All are overridable from the environment.
+export PYTHONFAULTHANDLER=1
+: ${PYTEST_TIMEOUT:=1200}          # per-test (per-parametrization) timeout, seconds
+: ${PYTEST_TIMEOUT_METHOD:=thread} # 'thread' reliably unsticks GPU/collective hangs
+: ${CTEST_TIMEOUT:=1200}           # per-cpp-test timeout, seconds
+
 _script_error_count=0
 _run_error_count=0
 _ignored_error_count=0
@@ -213,6 +224,12 @@ get_pytest_junitxml() {
     fi
 }
 
+get_ctest_junitxml() {
+    if [ -n "$JUNITXML_PREFIX$JUNITXML_SUFFIX" ]; then
+        echo "--output-junit ${JUNITXML_PREFIX}$1${JUNITXML_SUFFIX}"
+    fi
+}
+
 check_test_filter() {
     test -z "$TEST_FILTER" && return 0
     for _tf in $TEST_FILTER; do
@@ -266,7 +283,12 @@ pytest_run() {
     check_test_filter $_test_name_tag || return
     _start_ts=`date +%s`
     echo "Run [$_test_variant_tag] $@ at `time_elapsed $TEST_START_TS`"
-    python3 -m pytest -v -rfEs `get_pytest_junitxml $_test_name_tag` $TEST_PYTEST_ARGS "$TEST_DIR/$@"
+    # A per-test timeout is applied to every item. Callers may still append their
+    # own --timeout/--timeout-method (e.g. distributed tests); since argparse
+    # takes the last value, a caller-supplied override wins over these defaults.
+    python3 -m pytest -v -rfEs \
+        --timeout=$PYTEST_TIMEOUT --timeout-method=$PYTEST_TIMEOUT_METHOD \
+        `get_pytest_junitxml $_test_name_tag` $TEST_PYTEST_ARGS "$TEST_DIR/$@"
     test $? -eq 0 || test_run_error "[$_test_variant_tag] $1"
     echo "Done [$_test_variant_tag] $1 in `time_elapsed $_start_ts`"
 }
diff --git a/ci/core.sh b/ci/core.sh
index e940b12ff..7fbc40d95 100755
--- a/ci/core.sh
+++ b/ci/core.sh
@@ -31,14 +31,16 @@ fi
 check_test_filter "nongemm"
 if [ $? -eq 0 ]; then
     echo ===== Run non GEMM tests =====
-    ctest --test-dir build -j"$n_parallel_jobs" -V --output-on-failure -E "GEMMTestSuite"
+    ctest --test-dir build -j"$n_parallel_jobs" -V --output-on-failure \
+        --timeout $CTEST_TIMEOUT $(get_ctest_junitxml core.nongemm) -E "GEMMTestSuite"
     test $? -eq 0 || test_run_error "non-GEMM"
 fi
 
 check_test_filter "gemm"
 if [ $? -eq 0 ]; then
     echo  ===== Run GEMM tests =====
-    ctest --test-dir build -j"$n_parallel_jobs" -V --output-on-failure -R "GEMMTestSuite"
+    ctest --test-dir build -j"$n_parallel_jobs" -V --output-on-failure \
+        --timeout $CTEST_TIMEOUT $(get_ctest_junitxml core.gemm) -R "GEMMTestSuite"
     test $? -eq 0 || test_run_error "GEMM"
 fi
 
diff --git a/ci/jax.sh b/ci/jax.sh
index 0e1e356f6..9b0bccc1c 100755
--- a/ci/jax.sh
+++ b/ci/jax.sh
@@ -21,7 +21,7 @@ install_prerequisites() {
         script_error "Failed to install Flax and dependencies"
         return $rc
     fi
-    pip install pytest-timeout
+    pip install pytest-timeout etils
     rc=$?
     if [ $rc -ne 0 ]; then
         script_error "Failed to install test prerequisites"
@@ -72,7 +72,9 @@ run_test_config_mgpu() {
     # Mitigate distributed tests hang by adding 5min timeout
     _timeout_args="--timeout 300 --timeout-method thread"
     # Workaround for some distributed tests hang/abortion
-    export XLA_FLAGS="--xla_gpu_enable_nccl_comm_splitting=false"
+    export XLA_FLAGS="--xla_gpu_enable_nccl_comm_splitting=false --xla_cpu_enable_fast_math=false"
+    export JAX_COMPILATION_CACHE_DIR="/tmp/jax_cache"
+    export JAX_PERSISTENT_CACHE_MIN_COMPILE_TIME_SECS="0"
 
     if [ $_fus_attn = $_DEFAULT_FUSED_ATTN ]; then
         _dfa_level=2
@@ -82,12 +84,12 @@ run_test_config_mgpu() {
         export NVTE_JAX_UNITTEST_LEVEL=L2
     fi
 
-    run_default_fa 2 test_distributed_dense.py
+    run_default_fa 2 test_distributed_dense.py -p no:rerunfailures
     # RCCL_MSCCL_ENABLE=0 is to avoid hangs in some distributed tests (ROCM-1719)
-    RCCL_MSCCL_ENABLE=0 run $_dfa_level test_distributed_fused_attn.py $_timeout_args
-    run_default_fa 3 test_distributed_layernorm.py
-    run_default_fa 2 test_distributed_layernorm_mlp.py $_timeout_args
-    run_default_fa 3 test_distributed_softmax.py
+    RCCL_MSCCL_ENABLE=0 run $_dfa_level test_distributed_fused_attn.py $_timeout_args -p no:rerunfailures
+    run_default_fa 3 test_distributed_layernorm.py -p no:rerunfailures
+    run_default_fa 2 test_distributed_layernorm_mlp.py $_timeout_args -p no:rerunfailures
+    run_default_fa 3 test_distributed_softmax.py -p no:rerunfailures
 
     run_default_fa 3 test_sanity_import.py
 }
diff --git a/ci/junit_report.py b/ci/junit_report.py
new file mode 100644
index 000000000..550586e71
--- /dev/null
+++ b/ci/junit_report.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+
+"""Summarize pytest/ctest JUnit XML results into a GitHub Actions report.
+
+Reads every ``*.xml`` file in the given directory -- each produced by a single
+pytest file invocation (see ``get_pytest_junitxml`` in ``_utils.sh``) or a
+ctest run -- aggregates pass/fail/error/skip/timeout counts, writes a Markdown
+digest to ``$GITHUB_STEP_SUMMARY`` (or stdout when run locally), and emits
+``::error::`` workflow annotations for the failing tests.
+
+Design notes:
+  * Standard library only, so it runs on any runner without provisioning.
+  * Purely informational -- it always exits 0 and never gates the job. The
+    pass/fail gate stays with the existing ``FAIL_*`` markers / suite exit
+    codes. This keeps the change strictly additive.
+  * A run that is cut off mid-way (hang/crash/job-timeout) still produces a
+    digest for every test file that finished. Files whose XML is missing or
+    truncated are surfaced explicitly as "incomplete" rather than silently
+    dropped, which is exactly the signal that is invisible today.
+"""
+
+import glob
+import os
+import sys
+import xml.etree.ElementTree as ET
+from collections import defaultdict
+
+# UI shows at most ~10 annotations of each level; cap to keep the log readable.
+ANNOTATION_CAP = 20
+
+
+def iter_testsuites(root):
+    """Yield every <testsuite>; handles both <testsuites> and bare roots."""
+    if root.tag == "testsuite":
+        yield root
+    else:
+        yield from root.iter("testsuite")
+
+
+def classify(testcase):
+    """Return (status, first-line-message) for a <testcase>.
+
+    status is one of: passed, failed, error, skipped.
+    """
+    for tag, status in (("failure", "failed"), ("error", "error"), ("skipped", "skipped")):
+        el = testcase.find(tag)
+        if el is not None:
+            msg = (el.get("message") or el.text or "").strip()
+            return status, msg
+    return "passed", ""
+
+
+def is_timeout(message):
+    m = message.lower()
+    return "timeout" in m or "timed out" in m
+
+
+def emit(lines):
+    """Append the report to the step summary if available, else stdout."""
+    text = "\n".join(lines) + "\n"
+    summary = os.environ.get("GITHUB_STEP_SUMMARY")
+    if summary:
+        with open(summary, "a", encoding="utf-8") as fh:
+            fh.write(text)
+    else:
+        sys.stdout.write(text)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("usage: junit_report.py <results-dir> [--title TITLE]", file=sys.stderr)
+        return 0
+    results_dir = sys.argv[1]
+    title = "Test Results"
+    if "--title" in sys.argv:
+        title = sys.argv[sys.argv.index("--title") + 1]
+
+    xml_files = sorted(glob.glob(os.path.join(results_dir, "*.xml")))
+
+    lines = []
+    lines.append(f"## {title}\n")
+
+    if not xml_files:
+        lines.append(
+            "> :warning: **No JUnit XML files were produced.** No test file "
+            "completed far enough to write results -- the run likely crashed or "
+            "hung before any suite finished. Inspect the uploaded `*.log` "
+            "artifacts to see where it stopped.\n"
+        )
+        emit(lines)
+        return 0
+
+    totals = defaultdict(float)  # passed/failed/error/skipped/timeout/incomplete/time
+    per_file = []                # (name, counts, time)
+    failures = []                # (file, testid, label, message)
+
+    for xf in xml_files:
+        name = os.path.basename(xf)[: -len(".xml")]
+        counts = defaultdict(int)
+        suite_time = 0.0
+
+        try:
+            root = ET.parse(xf).getroot()
+        except (ET.ParseError, OSError) as exc:
+            # Truncated/unreadable XML => the pytest process was killed while
+            # writing it (hard timeout, segfault, or job cancellation).
+            counts["incomplete"] += 1
+            totals["incomplete"] += 1
+            per_file.append((name, counts, 0.0))
+            failures.append((name, "(whole file)", "incomplete",
+                             f"unparseable/truncated XML: {exc}"))
+            continue
+
+        for ts in iter_testsuites(root):
+            try:
+                suite_time += float(ts.get("time") or 0.0)
+            except ValueError:
+                pass
+            for tc in ts.findall("testcase"):
+                status, msg = classify(tc)
+                counts[status] += 1
+                totals[status] += 1
+                if status in ("failed", "error"):
+                    label = status
+                    if is_timeout(msg):
+                        label = "timeout"
+                        totals["timeout"] += 1
+                    cls = tc.get("classname", "")
+                    tcname = tc.get("name", "")
+                    testid = f"{cls}::{tcname}" if cls else tcname
+                    failures.append((name, testid, label,
+                                     msg.splitlines()[0] if msg else ""))
+
+        totals["time"] += suite_time
+        per_file.append((name, counts, suite_time))
+
+    n_pass = int(totals["passed"])
+    n_fail = int(totals["failed"])
+    n_err = int(totals["error"])
+    n_skip = int(totals["skipped"])
+    n_to = int(totals["timeout"])
+    n_incomplete = int(totals["incomplete"])
+    total_tests = n_pass + n_fail + n_err + n_skip
+
+    ok = (n_fail + n_err + n_incomplete) == 0
+    headline = ":white_check_mark:" if ok else ":x:"
+    summary_line = (
+        f"{headline} **{total_tests} tests** -- {n_pass} passed, {n_fail} failed, "
+        f"{n_err} errored, {n_skip} skipped"
+    )
+    if n_to:
+        summary_line += f" ({n_to} timed out)"
+    if n_incomplete:
+        summary_line += f"; **{n_incomplete} file(s) incomplete**"
+    summary_line += f" -- {totals['time']:.0f}s across {len(xml_files)} files\n"
+    lines.append(summary_line)
+
+    # Per-file breakdown (collapsed to keep the summary scannable).
+    lines.append("<details><summary>Per-file breakdown</summary>\n")
+    lines.append("| Test file (backend.label) | Pass | Fail | Error | Skip | Time (s) |")
+    lines.append("|---|---:|---:|---:|---:|---:|")
+    for name, counts, t in per_file:
+        bad = counts["failed"] + counts["error"] + counts["incomplete"]
+        mark = "" if bad == 0 else " :warning:"
+        lines.append(
+            f"| {name}{mark} | {counts['passed']} | {counts['failed']} | "
+            f"{counts['error']} | {counts['skipped']} | {t:.0f} |"
+        )
+    lines.append("\n</details>\n")
+
+    # Failure / error / timeout detail (always expanded -- this is the payload).
+    if failures:
+        lines.append("### Failures / errors / timeouts\n")
+        for fname, testid, label, msg in failures:
+            entry = f"- **[{label}]** `{testid}` _(in {fname})_"
+            if msg:
+                entry += f" -- {msg}"
+            lines.append(entry)
+        lines.append("")
+
+    emit(lines)
+
+    # Inline workflow annotations.
+    for i, (fname, testid, label, msg) in enumerate(failures):
+        if i >= ANNOTATION_CAP:
+            print(
+                f"::warning::{len(failures) - ANNOTATION_CAP} more failures "
+                "omitted from annotations; see the job summary for the full list."
+            )
+            break
+        body = msg or label
+        print(f"::error title={label}: {testid}::{body}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/ci/pytorch.sh b/ci/pytorch.sh
index 32fbf02f8..b63e880e7 100755
--- a/ci/pytorch.sh
+++ b/ci/pytorch.sh
@@ -12,7 +12,7 @@ TEST_DIR=${TE_PATH}tests/pytorch
 #: ${TEST_WORKERS:=4}
 
 install_prerequisites() {
-    pip install 'numpy>=1.22.4' pandas safetensors
+    pip install 'numpy>=1.22.4' pandas safetensors pytest-timeout
     rc=$?
     if [ $rc -ne 0 ]; then
         script_error "Failed to install test prerequisites"