diff --git a/.github/scripts/ci_sgpu_queue.conf b/.github/scripts/ci_sgpu_queue.conf
new file mode 100644
index 0000000000..598d530c7c
--- /dev/null
+++ b/.github/scripts/ci_sgpu_queue.conf
@@ -0,0 +1,19 @@
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+#
+# sGPU suite definitions for the work-queue scheduler (run_queue_sgpu.sh).
+# Format: <label>  <logfile>  <mode>  <command> [args...]
+#
+#   mode=list    suite honours TE_CI_LIST_ONLY, so it is expanded into one work
+#                item per test invocation and those items are packed across all
+#                GPUs. Items are re-dispatched with TEST_FILTER=<tag>.
+#   mode=opaque  suite is scheduled as a single work item (whole script).
+#
+# Unlike ci_sgpu_jobs.conf, line order carries no GPU assignment: every item
+# from every suite goes into one queue and workers pull on completion.
+
+examples  examples.log  opaque  .github/scripts/run_examples.sh
+torch     torch.log     list    ci/pytorch.sh
+jax       jax.log       list    ci/jax.sh
+core      core.log      opaque  ci/core.sh
diff --git a/.github/scripts/run_queue_sgpu.sh b/.github/scripts/run_queue_sgpu.sh
new file mode 100755
index 0000000000..abacad733c
--- /dev/null
+++ b/.github/scripts/run_queue_sgpu.sh
@@ -0,0 +1,480 @@
+#!/bin/bash
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+#
+# Run all sGPU test suites as one global work queue across N GPUs.
+#
+# Usage: run_queue_sgpu.sh [-l|--log-dir <dir>] [<config>...]
+#
+# Config format (one suite per line; # comments and blank lines are ignored):
+#   <label>  <logfile>  <mode>  <command> [args...]
+#     mode=list    expanded into one work item per test invocation
+#     mode=opaque  scheduled as a single work item
+#
+# With no config given, .github/scripts/ci_sgpu_queue.conf is used. Unlike
+# run_parallel_sgpu.sh, line order carries no GPU assignment: every item from
+# every config goes into one queue and workers pull on completion.
+#
+# The queue uses every GPU it can see; restrict it with HIP_VISIBLE_DEVICES.
+#
+# Example usage:
+#   TEST_LEVEL=1 .github/scripts/run_queue_sgpu.sh
+#   HIP_VISIBLE_DEVICES=0,1 TEST_LEVEL=1 .github/scripts/run_queue_sgpu.sh
+#
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+# Two directories in the repo root:
+#
+#   test-results/  everything one run produced; this script adds logs/ under it
+#   ci-weights/    the learned weight table, the one thing that must outlive the
+#                  run that measured it. Same name the workflow caches.
+: "${LOG_DIR:=${REPO_ROOT}/test-results/logs}"
+
+# Items with no recorded weight sort first: an unknown item is more likely to be
+# a new (or newly slow) one, and a long item started late is what stretches the
+# tail. Losing the gamble costs far less than mis-scheduling a genuinely big item.
+: "${DEFAULT_WEIGHT:=${TE_CI_DEFAULT_WEIGHT:-999999}}"
+
+# Run state:  CONFIGS[]   suite lists to read, in the order given
+#             GPU_IDS[]   the worker pool, and where it was read from
+#             SUITE_*[]   the configs as parsed by Phase 0: one entry per config
+#                         line, in file order, shared index across all five.
+#                         Phases 1, 3 and 5 all walk them rather than re-reading
+#                         the files, so the parse happens once.
+declare -a CONFIGS=()
+declare -a GPU_IDS=()
+declare -a SUITE_LABELS=()
+declare -a SUITE_LOGFILES=()
+declare -a SUITE_MODES=()
+declare -a SUITE_CMDS=()
+declare -a SUITE_ARGS=()
+GPU_SOURCE=""
+OVERALL_RC=0
+
+if [[ -n "${GITHUB_ACTIONS:-}" ]]; then
+    log_error() { echo "::error::$*" >&2; }
+    log_warn()  { echo "::warning::$*" >&2; }
+else
+    log_error() { echo "Error: $*" >&2; }
+    log_warn()  { echo "Warning: $*" >&2; }
+fi
+
+# Fill GPU_IDS with every GPU this run can see: HIP_VISIBLE_DEVICES if set
+# else what rocminfo counts. Returns 1 if there is none.
+detect_gpu_pool() {
+    local n k
+    if [[ -n "${HIP_VISIBLE_DEVICES:-}" ]]; then
+        IFS=',' read -r -a GPU_IDS <<< "$HIP_VISIBLE_DEVICES"
+        GPU_SOURCE="HIP_VISIBLE_DEVICES=$HIP_VISIBLE_DEVICES"
+        return 0
+    fi
+    n=$(rocminfo 2>/dev/null | grep -c 'Device Type:.*GPU')
+    [[ -n "$n" && "$n" -gt 0 ]] || return 1
+    for ((k = 0; k < n; k++)); do GPU_IDS+=( "$k" ); done
+    GPU_SOURCE="rocminfo${ROCR_VISIBLE_DEVICES:+, ROCR_VISIBLE_DEVICES=$ROCR_VISIBLE_DEVICES}"
+}
+
+detect_arch() {
+    rocminfo 2>/dev/null | grep -E "^ *Name: *gfx" | head -1 | sed "s/.*gfx/gfx/;s/[: ].*//"
+}
+
+# Echo the next queue index and advance it. Every worker calls this, so the
+# read-modify-write is done under flock.
+take_next() {
+    local i
+    {
+        flock 9
+        i=$(cat "$IDX_FILE")
+        echo $((i + 1)) > "$IDX_FILE"
+    } 9<>"$LOCK_FILE"
+    echo "$i"
+}
+
+# Usage: worker <gpu>
+# Pull items off the queue until it is empty, running each one on <gpu> and
+# appending its timing record to TIMINGS_FILE.
+worker() {
+    local gpu=$1
+    local i line weight label cmd tag rest itemlog rc safetag junit_dir start end incomplete
+    while :; do
+        i=$(take_next)
+        [[ "$i" -gt "$TOTAL_ITEMS" ]] && break
+        line=$(sed -n "${i}p" "$QUEUE_FILE")
+        [[ -z "$line" ]] && break
+        IFS=$'\t' read -r weight label cmd tag rest <<< "$line"
+
+        safetag="${tag:-whole}"
+        itemlog="$ITEM_LOG_DIR/${label}.${safetag}.log"
+        if [[ -n "${JUNITXML_PREFIX:-}${JUNITXML_SUFFIX:-}" ]]; then
+            junit_dir="${JUNITXML_PREFIX:-}${label}/"
+            mkdir -p "$junit_dir"
+        else
+            junit_dir=""
+        fi
+
+        # No scheduler-imposed deadline: the suite scripts' own PYTEST_TIMEOUT and
+        # the workflow's timeout-minutes are the only limits, exactly as they are
+        # outside the queue.
+        start=$(date +%s)
+        if [[ -n "$tag" ]]; then
+            HIP_VISIBLE_DEVICES=$gpu TE_CI_SKIP_SETUP=1 TEST_FILTER="$tag" \
+                JUNITXML_PREFIX="$junit_dir" \
+                "$cmd" ${rest:-} > "$itemlog" 2>&1
+        else
+            HIP_VISIBLE_DEVICES=$gpu JUNITXML_PREFIX="$junit_dir" \
+                "$cmd" ${rest:-} > "$itemlog" 2>&1
+        fi
+        rc=$?
+        end=$(date +%s)
+
+        echo "$rc" > "${itemlog}.rc"
+
+        # A te_ci_result_sink sidecar that outlived the process means pytest
+        # never reached its end-of-session write -- a --timeout-method=thread
+        # expiry, a segfault, or an OOM-kill -- so this duration is where the
+        # item was cut off, not what it costs. rc cannot be used to tell: a
+        # thread-method timeout exits 1, indistinguishable from an ordinary test
+        # failure, which is a perfectly good measurement. build_weights.py drops
+        # the flagged rows rather than teaching the table a truncated number.
+        incomplete=0
+        if [[ -n "$junit_dir" ]]; then
+            if [[ -n "$tag" ]]; then
+                # Items sharing a label share junit_dir, so only this item's own
+                # sidecar may be consulted -- a glob would see the in-flight
+                # sidecar of an item still running on another GPU.
+                [[ -e "${junit_dir}${tag}${JUNITXML_SUFFIX:-}.partial" ]] && incomplete=1
+            elif compgen -G "${junit_dir}*.partial" > /dev/null; then
+                incomplete=1   # opaque suite: it is the only item in its dir
+            fi
+        fi
+
+        # Machine-readable timing record. The first five columns are the stable
+        # contract build_weights.py reads; the scheduling columns are appended
+        # after them so that reader stays unchanged. Written incrementally so a
+        # run killed by the job timeout still leaves a usable record of
+        # everything that had completed.
+        printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' \
+            "$label" "$safetag" "$gpu" "$((end - start))" "$rc" \
+            "$((start - START_TS))" "$((end - START_TS))" "$weight" "$incomplete" \
+            >> "$TIMINGS_FILE"
+        printf '[%s] gpu%-2s t+%-7s %5ss rc=%-4s est=%-8s %-9s %s\n' \
+            "$(date '+%H:%M:%S')" "$gpu" "$((start - START_TS))s" "$((end - start))" \
+            "$rc" "$([[ $weight -eq $DEFAULT_WEIGHT ]] && echo unknown || echo "${weight}s")" \
+            "$label" "$safetag"
+    done
+}
+
+# ---------------------------------------------------------------------------
+# Parse arguments
+# ---------------------------------------------------------------------------
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        -l|--log-dir)
+            LOG_DIR="$2"; shift 2 ;;
+        --log-dir=*)
+            LOG_DIR="${1#*=}"; shift ;;
+        -*)
+            echo "Unknown option: $1" >&2
+            echo "Usage: $0 [-l|--log-dir <dir>] [<config>...]" >&2
+            exit 1 ;;
+        *)
+            break ;;
+    esac
+done
+
+# Resolve config paths to absolute against the caller's CWD *before* changing
+# directory, so relative paths passed by the caller remain valid: Phase 0 reads
+# them below, but the commands they name are not run until after the cd to the
+# repo root.
+if [[ $# -gt 0 ]]; then
+    for c in "$@"; do CONFIGS+=( "$(realpath -m "$c")" ); done
+else
+    CONFIGS=( "${SCRIPT_DIR}/ci_sgpu_queue.conf" )
+fi
+for c in "${CONFIGS[@]}"; do
+    if [[ ! -f "$c" ]]; then
+        log_error "suite list not found: $c"
+        exit 1
+    fi
+done
+
+# ---------------------------------------------------------------------------
+# Phase 0: read the configs and reject a bad one
+# ---------------------------------------------------------------------------
+for config in "${CONFIGS[@]}"; do
+    while IFS= read -r line || [[ -n "$line" ]]; do
+        [[ "$line" =~ ^[[:space:]]*# ]] && continue
+        [[ -z "${line//[[:space:]]/}" ]] && continue
+        read -r label logfile mode cmd rest <<< "$line"
+        SUITE_LABELS+=( "$label" )
+        SUITE_LOGFILES+=( "$logfile" )
+        SUITE_MODES+=( "$mode" )
+        SUITE_CMDS+=( "$cmd" )
+        SUITE_ARGS+=( "${rest:-}" )
+    done < "$config"
+done
+
+if [[ ${#SUITE_LABELS[@]} -eq 0 ]]; then
+    log_error "no suites to run: ${CONFIGS[*]} contain only comments and blank lines"
+    exit 1
+fi
+
+# Reject duplicate labels across configs: the queue is keyed by label
+dupe_labels=$(printf '%s\n' "${SUITE_LABELS[@]}" | sort | uniq -d)
+if [[ -n "$dupe_labels" ]]; then
+    log_error "duplicate suite labels across configs:"
+    echo "$dupe_labels" >&2
+    exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Set up the run: GPU pool, arch, weight table, log tree
+# ---------------------------------------------------------------------------
+if ! detect_gpu_pool; then
+    log_error "no GPU found: rocminfo reports none and HIP_VISIBLE_DEVICES is unset." \
+              "Set HIP_VISIBLE_DEVICES to the devices this run may use."
+    exit 1
+fi
+
+NUM_GPUS=${#GPU_IDS[@]}
+echo "== GPUs: ${NUM_GPUS} visible -- ids ${GPU_IDS[*]} (via ${GPU_SOURCE}) =="
+
+ARCH=$(detect_arch)
+if [[ -z "$ARCH" ]]; then
+    log_error "could not read the GPU arch from rocminfo; it keys the weight table"
+    exit 1
+fi
+echo "== Arch: ${ARCH} =="
+
+# The weight table is keyed by arch and TEST_LEVEL 
+WEIGHTS_FILE="${REPO_ROOT}/ci-weights/test_weights.${ARCH}.l${TEST_LEVEL:-99}.txt"
+mkdir -p "$(dirname "$WEIGHTS_FILE")" 2>/dev/null
+
+[[ "$LOG_DIR" != /* ]] && LOG_DIR="$(realpath -m "$LOG_DIR")"
+
+
+# One directory per phase, so "where did that come from" is answered by the path
+# and a phase can be cleared without touching the others:
+#
+#   prerequisite_ck_jit_status/ Phase 3  one-time prerequisites per suite
+#   items/                      Phase 4  the test output itself -- one file per item
+#   suites/                     Phase 5  per-suite verdict: rc + index into items/
+#   report/                     Phase 7  the human-readable schedule
+#   queue/                               the machine-readable state: what to run,
+#                                        what it cost
+#
+# Phase 1 has no directory: what it produced is queue.tsv and items.tsv, and all
+# it has of its own is whatever the suites printed on stderr while listing, which
+# is one file.
+EXPAND_LOG="$LOG_DIR/expand.log"
+SETUP_DIR="$LOG_DIR/prerequisite_ck_jit_status"
+ITEM_LOG_DIR="$LOG_DIR/items"
+SUITE_LOG_DIR="$LOG_DIR/suites"
+REPORT_DIR="$LOG_DIR/report"
+QUEUE_DIR="$LOG_DIR/queue"
+
+rm -rf "${REPO_ROOT}/test-results"
+rm -rf "$ITEM_LOG_DIR" "$SUITE_LOG_DIR"
+
+mkdir -p "$SETUP_DIR" "$ITEM_LOG_DIR" "$SUITE_LOG_DIR" "$REPORT_DIR" "$QUEUE_DIR"
+: > "$EXPAND_LOG"
+
+# 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; }
+
+QUEUE_FILE="$QUEUE_DIR/queue.tsv"
+ITEMS_FILE="$QUEUE_DIR/items.tsv"
+LIST_TMP="$QUEUE_DIR/.expand.tmp"
+TIMINGS_FILE="$QUEUE_DIR/timings.tsv"
+IDX_FILE="$QUEUE_DIR/queue.idx"
+LOCK_FILE="$QUEUE_DIR/queue.lock"
+: > "$QUEUE_FILE"
+: > "$ITEMS_FILE"
+# Phase 2 removes this, but only if it gets that far: an expansion that bails out
+# leaves it behind, and re-running into the same log dir would then append to the
+# previous attempt and trip the duplicate-tag check. Local runs do that a lot.
+: > "$QUEUE_FILE.raw"
+
+# ---------------------------------------------------------------------------
+# Phase 1: expand every suite into work items
+# ---------------------------------------------------------------------------
+#
+# List mode runs the suite script with TE_CI_LIST_ONLY=1, which makes pytest_run
+# echo "TE_CI_ITEM <tag>" for each invocation it would have made instead of
+# running it.
+#
+# Every list-mode suite is listed twice, because "will run" and "exists" are
+# different questions:
+#
+#   run 1  LIST_ONLY             what this host will run     -> the queue
+#   run 2  LIST_ONLY + LIST_ALL  what exists at this level   -> items.tsv
+#
+# So run2 - run1 is what this host skipped -- no flash-attn, say -- and those
+# tests do still exist. Only a tag in neither list is gone for good, and that is
+# what build_weights.py prunes on.
+echo "== Expanding test suites into work items =="
+for i in "${!SUITE_LABELS[@]}"; do
+    label="${SUITE_LABELS[$i]}"
+    mode="${SUITE_MODES[$i]}"
+    cmd="${SUITE_CMDS[$i]}"
+    rest="${SUITE_ARGS[$i]}"
+    if [[ "$mode" == "list" ]]; then
+        echo "=== ${label}: list -- what this runner will run ===" >> "$EXPAND_LOG"
+        TE_CI_LIST_ONLY=1 "$cmd" ${rest:-} > "$LIST_TMP" 2>> "$EXPAND_LOG"
+        list_rc=$?
+        mapfile -t tags < <(sed -n 's/^TE_CI_ITEM //p' "$LIST_TMP")
+
+        if [[ $list_rc -ne 0 ]]; then
+            log_error "suite '${label}' (${cmd}) reported an error while listing (rc=${list_rc})"
+            tail -20 "$EXPAND_LOG" >&2
+            exit 1
+        fi
+        if [[ ${#tags[@]} -eq 0 ]]; then
+            log_error "suite '${label}' (${cmd}) produced no work items"
+            tail -20 "$EXPAND_LOG" >&2
+            exit 1
+        fi
+        for tag in "${tags[@]}"; do
+            printf '%s\t%s\t%s\t%s\n' "$label" "$cmd" "$tag" "${rest:-}" >> "$QUEUE_FILE.raw"
+        done
+
+        echo "=== ${label}: list-all -- what exists at this level ===" >> "$EXPAND_LOG"
+        TE_CI_LIST_ONLY=1 TE_CI_LIST_ALL=1 "$cmd" ${rest:-} > "$LIST_TMP" 2>> "$EXPAND_LOG"
+        all_rc=$?
+        mapfile -t all_tags < <(sed -n 's/^TE_CI_ITEM //p' "$LIST_TMP")
+
+        if [[ $all_rc -ne 0 ]]; then
+            log_warn "suite '${label}': list-all reported an error (rc=${all_rc}) after" \
+                     "returning ${#all_tags[@]} items; its weights will not be pruned"
+        else
+            for tag in "${all_tags[@]}"; do
+                printf '%s\t%s\n' "$label" "$tag" >> "$ITEMS_FILE"
+            done
+        fi
+        echo "  ${label}: ${#tags[@]} items (${#all_tags[@]} exist at this level)"
+    else
+        printf '%s\t%s\t%s\t%s\n' "$label" "$cmd" "" "${rest:-}" >> "$QUEUE_FILE.raw"
+        printf '%s\t%s\n' "$label" "" >> "$ITEMS_FILE"
+        echo "  ${label}: 1 item (opaque)"
+    fi
+done
+rm -f "$LIST_TMP"
+
+# ---------------------------------------------------------------------------
+# Phase 2: weight and order the queue (longest processing time first)
+# ---------------------------------------------------------------------------
+#
+# build_weights.py owns the weight table at both ends -- it applies the table
+# here and rewrites it in Phase 6.
+if ! python3 "$REPO_ROOT/.github/scripts/scheduler/build_weights.py" order "$QUEUE_FILE.raw" \
+        --weights "$WEIGHTS_FILE" \
+        --output "$QUEUE_FILE" \
+        --default-weight "$DEFAULT_WEIGHT" \
+        --gpus "${GPU_IDS[*]}"; then
+    log_error "could not order the queue"
+    exit 1
+fi
+rm -f "$QUEUE_FILE.raw"
+
+TOTAL_ITEMS=$(wc -l < "$QUEUE_FILE")
+
+# ---------------------------------------------------------------------------
+# Phase 3: one-time, container-wide setup
+# ---------------------------------------------------------------------------
+#
+# pip prerequisites and the CK JIT blob cache are container-wide filesystem
+# state, so each suite installs and prebuilds them once here.
+setup_banner=""
+for i in "${!SUITE_LABELS[@]}"; do
+    label="${SUITE_LABELS[$i]}"
+    cmd="${SUITE_CMDS[$i]}"
+    # Only list-mode suites have a setup/dispatch split; an opaque suite is a
+    # single invocation that still does its own setup inline.
+    [[ "${SUITE_MODES[$i]}" == "list" ]] || continue
+    if [[ -z "$setup_banner" ]]; then
+        echo "== One-time setup: pip prerequisites + CK JIT prebuild (once per suite) =="
+        setup_banner=1
+    fi
+    printf '  %s: installing prerequisites, prebuilding CK JIT blobs (%s) ... ' "$label" "$cmd"
+    setup_start=$(date +%s)
+    if ! HIP_VISIBLE_DEVICES=${GPU_IDS[0]} TE_CI_SETUP_ONLY=1 "$cmd" \
+            > "$SETUP_DIR/${label}.log" 2>&1; then
+        echo "FAILED"
+        log_error "setup failed for ${label}; see $SETUP_DIR/${label}.log"
+        tail -30 "$SETUP_DIR/${label}.log" >&2
+        exit 1
+    fi
+    echo "done in $(( $(date +%s) - setup_start ))s"
+done
+
+# ---------------------------------------------------------------------------
+# Phase 4: run the queue
+# ---------------------------------------------------------------------------
+echo 1 > "$IDX_FILE"
+: > "$LOCK_FILE"
+: > "$TIMINGS_FILE"
+START_TS=$(date +%s)
+
+for gpu in "${GPU_IDS[@]}"; do
+    worker "$gpu" &
+done
+wait
+
+WALL=$(( $(date +%s) - START_TS ))
+# The report divides by WALL in several places; a run short enough to round to
+# zero seconds would otherwise abort the whole report on a division by zero.
+[[ $WALL -lt 1 ]] && WALL=1
+
+# ---------------------------------------------------------------------------
+# Phase 5: roll per-item results up into a per-suite verdict
+# ---------------------------------------------------------------------------
+#
+# Two outputs per suite, both keyed by the logfile name from the config so the
+# workflow's failure gate keeps reading the same name: the exit code it gates on,
+# and an index of which items ran and how each one ended.
+for i in "${!SUITE_LABELS[@]}"; do
+    label="${SUITE_LABELS[$i]}"
+    # Phase 1 fails a suite that expands to nothing, so this should never skip.
+    # It stays because the alternative to skipping is an empty suite log and
+    # rc=0, which reads as "passed" to the workflow's gate.
+    awk -F'\t' -v l="$label" '$2==l {found=1} END {exit !found}' "$QUEUE_FILE" || continue
+    suite_log="$SUITE_LOG_DIR/${SUITE_LOGFILES[$i]}"
+    : > "$suite_log"
+    worst=0
+    for itemlog in "$ITEM_LOG_DIR/${label}."*.log; do
+        [[ -e "$itemlog" ]] || continue
+        rc=$(cat "${itemlog}.rc" 2>/dev/null || echo 1)
+        printf '%-4s rc=%-4s items/%s\n' \
+            "$([[ "$rc" == "0" ]] && echo ok || echo FAIL)" "$rc" \
+            "$(basename "$itemlog")" >> "$suite_log"
+        [[ "$rc" != "0" ]] && worst=$rc
+    done
+    echo "$worst" > "${suite_log}.rc"
+    [[ "$worst" != "0" ]] && OVERALL_RC=$worst
+done
+
+# ---------------------------------------------------------------------------
+# Phase 6: update the learned weight table for the next run
+# ---------------------------------------------------------------------------
+echo
+if ! python3 "$REPO_ROOT/.github/scripts/scheduler/build_weights.py" update "$TIMINGS_FILE" \
+        --items "$ITEMS_FILE" -o "$WEIGHTS_FILE"; then
+    log_warn "could not update $WEIGHTS_FILE; the next run will use the table as it stands"
+fi
+
+# ---------------------------------------------------------------------------
+# Phase 7: scheduling report
+# ---------------------------------------------------------------------------
+if ! python3 "$REPO_ROOT/.github/scripts/scheduler/schedule_report.py" "$LOG_DIR" \
+        --gpus "${GPU_IDS[*]}" \
+        --wall "$WALL" \
+        --default-weight "$DEFAULT_WEIGHT" \
+        --weights "$WEIGHTS_FILE"; then
+    log_warn "could not write the scheduling report"
+fi
+
+exit $OVERALL_RC
diff --git a/.github/scripts/scheduler/build_weights.py b/.github/scripts/scheduler/build_weights.py
new file mode 100755
index 0000000000..344b500f46
--- /dev/null
+++ b/.github/scripts/scheduler/build_weights.py
@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+
+"""Order/Update the sGPU scheduler's weight table.
+
+  order  : Read the cached weight table and apply it to sort the scheduler's queue by longest-processing-time first.
+  update : Read a finished run's timings and blend them into the cached weight table.
+"""
+
+import argparse
+import sys
+
+from queue_files import KILLED_RCS, read_timings
+
+
+def measurements(frame):
+    """Split one run's timings into what it measured and what it merely ran.
+
+    Returns ``(measured, dispatched)``, which answer different questions and go
+    to different places:
+
+      measured    key -> seconds, for the rows worth learning from.
+                  Blended into the table by ``merge_weights``.
+      dispatched  every key the run started, learned from or not. Used by
+                  ``prune_weights``, which only needs to know the item exists.
+
+    A row is kept out of ``measured`` when its duration records where the item
+    was stopped rather than what it costs:
+
+      rc in KILLED_RCS   124 from a ``timeout`` expiry, 137 from a SIGKILL or an
+                         OOM-kill: killed from outside, so the duration is a
+                         ceiling imposed on it.
+      incomplete == 1    pytest never reached its end-of-session write, which rc
+                         cannot say on its own -- a ``--timeout-method=thread``
+                         expiry exits 1, indistinguishable from an ordinary test
+                         failure. The scheduler raises the flag from the result
+                         sidecar the dying process left behind.
+
+    Both still count as dispatched: the item plainly exists, it just taught the
+    table nothing this run.
+    """
+    # "whole" is the scheduler's placeholder for an opaque suite item, which the
+    # weight table keys by bare label rather than by "<label>/<tag>".
+    key = frame["label"].where(frame["tag"] == "whole", frame["name"])
+    usable = ~frame["rc"].isin(KILLED_RCS) & (frame["incomplete"] != 1)
+    measured = frame["secs"][usable].groupby(key[usable]).sum()
+    return measured.to_dict(), set(key)
+
+
+def item_key(label, tag):
+    """The table key for one work item.
+
+    An opaque whole-suite item has no tag and is keyed by bare label; everything
+    else by ``<label>/<tag>``. Every reader and writer goes through here
+    """
+    return f"{label}/{tag}" if tag else label
+
+
+def read_items(path):
+    """Read items.tsv -- every work item that exists at this TEST_LEVEL"""
+    try:
+        handle = open(path, encoding="utf-8")
+    except OSError as err:
+        print(f"warning: cannot read {path} ({err}); nothing will be pruned", file=sys.stderr)
+        return None, None
+    keys, labels = set(), set()
+    with handle:
+        for line in handle:
+            label, _, tag = line.rstrip("\n").partition("\t")
+            if not label:
+                continue
+            labels.add(label)
+            keys.add(item_key(label, tag))
+    return keys, labels
+
+
+def read_weights(path):
+    """Read the cached weight table the scheduler uses to sort the queue."""
+    weights = {}
+    try:
+        handle = open(path, encoding="utf-8")
+    except OSError:
+        return weights
+    with handle:
+        for line in handle:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            key, _, value = line.rpartition(" ")
+            try:
+                weights[key] = float(value)
+            except ValueError:
+                continue
+    return weights
+
+
+QUEUE_COLUMNS = 4  # label, cmd, tag, rest
+
+
+def read_queue(path):
+    """Read the unweighted queue the expansion phase wrote."""
+    rows = []
+    with open(path, encoding="utf-8") as handle:
+        for line in handle:
+            line = line.rstrip("\n")
+            if not line.strip():
+                continue
+            fields = line.split("\t")
+            fields += [""] * (QUEUE_COLUMNS - len(fields))
+            rows.append(tuple(fields[:QUEUE_COLUMNS]))
+    return rows
+
+
+def order_queue(rows, weights, default_weight):
+    """Weight every work item and sort the queue longest-processing-time first.
+
+    LPT is the standard makespan heuristic: dispatch the long items first and
+    what is left to fill the tail is short, so no GPU is still starting a big
+    item once the others have gone idle. An item the table has never seen takes
+    ``default_weight``, which sorts it first -- see the scheduler for why that
+    gamble is the cheap direction.
+    """
+    weighted = [
+        (int(weights.get(item_key(label, tag), default_weight)), label, cmd, tag, rest)
+        for label, cmd, tag, rest in rows
+    ]
+    weighted.sort(key=lambda row: -row[0])
+    return weighted
+
+
+def plan_lines(queue, weights_path, n_weights, gpu_ids, default_weight):
+    """Render what the scheduler intends to do, before it does any of it."""
+
+    def est(weight):
+        return "unknown" if weight == default_weight else f"{weight}s"
+
+    n_gpus = len(gpu_ids) or 1
+    lines = [f"== Queue: {len(queue)} items over {n_gpus} GPUs ({' '.join(gpu_ids)}) =="]
+    if n_weights:
+        lines.append(f"   weights: {weights_path} ({n_weights} items)")
+    else:
+        lines.append(f"   weights: none yet -- this run is unordered and will write {weights_path}")
+
+    lines.append("== Queue plan (dispatch order; est = weight used to sort) ==")
+    total = 0
+    for position, (weight, label, _cmd, tag, _rest) in enumerate(queue, 1):
+        total += weight
+        lines.append(f"  {position:3d}. est={est(weight):<8} {label:<9} {tag or '(whole suite)'}")
+    lines.append("")
+    lines.append(
+        f"  estimated work {total}s over {n_gpus} GPUs -> lower bound {total / n_gpus:.0f}s"
+        f" (largest item {est(queue[0][0])})"
+    )
+    return lines
+
+
+def merge_weights(old, new, alpha_up=0.5, alpha_down=0.1):
+    """Update cached table with new weights from current run.
+
+    Every key already in the table moves by an exponential average,
+    ``(1 - alpha) * previous + alpha * measured``; a key the table has never
+    seen takes its measurement whole. The rate depends on which way it moved:
+
+      alpha_up    0.5, when the item got slower -- half the gap closed in one
+                  run.
+      alpha_down  0.1, when it got faster -- a tenth of it.
+
+    The two differ because the scheduler's two error directions do not cost the
+    same. Over-estimating an item only starts it earlier than it needed to be
+    started; under-estimating one leaves it running after the other GPUs have
+    gone idle, and that is what sets the makespan. So a rise is trusted quickly
+    and a fall slowly.
+
+    The slow fall also makes the table shrug off a single short run -- a crash
+    partway through, or a machine having a fast day -- without anyone needing to
+    decide whether that run was "valid".
+    """
+    merged = dict(old)
+    for key, value in new.items():
+        previous = merged.get(key)
+        if previous is None:
+            merged[key] = value
+            continue
+        alpha = alpha_up if value > previous else alpha_down
+        merged[key] = (1.0 - alpha) * previous + alpha * value
+    return merged
+
+
+def prune_weights(weights, dispatched, live_keys, live_labels):
+    """Drop the weights of work items that no longer exist.
+
+    A key survives if item.tsv lists it.
+    """
+    kept, pruned = {}, []
+    for key, value in weights.items():
+        label = key.split("/", 1)[0]
+        if key in dispatched or label not in live_labels or key in live_keys:
+            kept[key] = value
+        else:
+            pruned.append(key)
+    return kept, pruned
+
+
+def run_order(args):
+    """Apply the cached weight table to the queue and send it to the scheduler."""
+    try:
+        rows = read_queue(args.queue)
+    except OSError as err:
+        print(f"error: cannot read {args.queue} ({err})", file=sys.stderr)
+        return 1
+    if not rows:
+        print("error: queue is empty: every suite expanded to nothing", file=sys.stderr)
+        return 1
+
+    weights = read_weights(args.weights)
+    queue = order_queue(rows, weights, args.default_weight)
+    try:
+        with open(args.output, "w", encoding="utf-8") as handle:
+            for row in queue:
+                handle.write("\t".join(str(field) for field in row) + "\n")
+    except OSError as err:
+        print(f"error: cannot write {args.output} ({err})", file=sys.stderr)
+        return 1
+
+    for line in plan_lines(
+        queue, args.weights, len(weights), args.gpus.split(), args.default_weight
+    ):
+        print(line)
+    return 0
+
+
+def run_update(args):
+    """Blend a finished run's measurements into the table and update the cache."""
+    measured, dispatched = measurements(read_timings(args.timings))
+    if not measured:
+        # Every row was killed, cut short or malformed. There is nothing to
+        # learn and the existing table is still the best estimate available, so
+        # leave it exactly as it is rather than rewriting it from nothing.
+        print(f"error: no usable measurements in {args.timings}", file=sys.stderr)
+        return 1
+
+    previous = read_weights(args.output)
+    weights = merge_weights(previous, measured)
+    print(
+        f"merged {len(measured)} measurements into {len(previous)} known weights "
+        f"({len(set(weights) - set(previous))} new)",
+        file=sys.stderr,
+    )
+
+    if args.items:
+        live_keys, live_labels = read_items(args.items)
+        if live_keys is not None:
+            weights, pruned = prune_weights(weights, dispatched, live_keys, live_labels)
+            # Named individually rather than counted: a prune is how a deleted
+            # test leaves the table, and it is also exactly what a broken suite
+            # expansion would look like, so the list is worth reading.
+            for key in sorted(pruned):
+                print(f"pruned {key}: its suite no longer lists it", file=sys.stderr)
+
+    lines = [
+        f"{key} {value:.1f}\n" for key, value in sorted(weights.items(), key=lambda kv: -kv[1])
+    ]
+    with open(args.output, "w", encoding="utf-8") as handle:
+        handle.writelines(lines)
+    print(f"wrote {len(lines)} weights to {args.output}", file=sys.stderr)
+    return 0
+
+
+def main():
+    """Dispatch to ``order`` (apply the table) or ``update`` (rewrite it)."""
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    order = sub.add_parser(
+        "order", help="apply the table: weight a queue and sort it longest-first"
+    )
+    order.add_argument("queue", metavar="QUEUE", help="the unweighted queue from expansion")
+    order.add_argument(
+        "-w", "--weights", required=True, metavar="TABLE", help="weight table to read"
+    )
+    order.add_argument(
+        "-o", "--output", required=True, metavar="FILE", help="where to write the sorted queue"
+    )
+    order.add_argument(
+        "--default-weight",
+        type=int,
+        required=True,
+        metavar="SECS",
+        help="weight for an item the table has never seen; it sorts first",
+    )
+    order.add_argument(
+        "--gpus", default="", metavar="IDS", help='space-separated device ids, e.g. "0 1 2 4"'
+    )
+
+    update = sub.add_parser("update", help="fold a finished run's timings into the table")
+    update.add_argument(
+        "timings", metavar="TIMINGS", help="timings.tsv written by run_queue_sgpu.sh"
+    )
+    update.add_argument(
+        "-o", "--output", required=True, metavar="TABLE", help="weight table to update in place"
+    )
+    update.add_argument(
+        "--items",
+        metavar="FILE",
+        help="items.tsv listing every work item that exists at this level; "
+        "without it, no weight is ever pruned",
+    )
+
+    args = parser.parse_args()
+    return run_order(args) if args.command == "order" else run_update(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.github/scripts/scheduler/queue_files.py b/.github/scripts/scheduler/queue_files.py
new file mode 100644
index 0000000000..1beb0ed00d
--- /dev/null
+++ b/.github/scripts/scheduler/queue_files.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+
+"""The ``timings.tsv`` contract, shared by the two tools that read it.
+
+``run_queue_sgpu.sh`` appends one row per work item as it dispatches. Two tools
+consume that file afterwards -- ``build_weights.py`` to learn the next run's
+schedule and ``schedule_report.py`` to report on this one
+
+Columns, in order:
+
+  label       suite label, e.g. "torch"
+  tag         work item within the suite, or "whole" for an opaque suite
+  gpu         HIP device id it ran on, as written (ids need not start at zero)
+  secs        wall-clock duration
+  rc          exit code of the suite invocation
+  start_off   seconds from the start of the queue to this item's start
+  end_off     seconds from the start of the queue to this item's finish
+  est         the weight used to schedule it, or the caller's default weight
+  incomplete  1 if the item was cut off mid-way
+"""
+
+import pandas as pd
+
+COLUMNS = ["label", "tag", "gpu", "secs", "rc", "start_off", "end_off", "est", "incomplete"]
+TEXT_COLUMNS = ["label", "tag", "gpu"]
+NUMERIC_COLUMNS = ["secs", "rc", "start_off", "end_off", "est", "incomplete"]
+
+# rc values that mean the item was killed rather than measured. 124 is a GNU
+# timeout expiry (the job's own step timeout, for instance), 137 a SIGKILL or an
+# OOM-kill.
+KILLED_RCS = frozenset((124, 137))
+
+
+def read_timings(path):
+    """``timings.tsv`` as a DataFrame, one row per dispatched work item."""
+    try:
+        frame = pd.read_csv(
+            path,
+            sep="\t",
+            header=None,
+            names=COLUMNS,
+            dtype={c: str for c in TEXT_COLUMNS},
+            keep_default_na=False,
+            na_values=[],
+            on_bad_lines="skip",
+        )
+    except (OSError, pd.errors.EmptyDataError):
+        frame = pd.DataFrame({c: pd.Series(dtype=str) for c in COLUMNS})
+
+    for column in NUMERIC_COLUMNS:
+        frame[column] = pd.to_numeric(frame[column], errors="coerce")
+    # A short row leaves NaN in the numeric columns; a torn one leaves garbage
+    # that to_numeric just turned into NaN. Either way there is no measurement.
+    frame = frame.dropna(subset=NUMERIC_COLUMNS)
+    frame[NUMERIC_COLUMNS] = frame[NUMERIC_COLUMNS].astype(int)
+
+    frame["name"] = frame["label"] + "/" + frame["tag"]
+    return frame.reset_index(drop=True)
diff --git a/.github/scripts/scheduler/schedule_report.py b/.github/scripts/scheduler/schedule_report.py
new file mode 100644
index 0000000000..009e86112c
--- /dev/null
+++ b/.github/scripts/scheduler/schedule_report.py
@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026, Advanced Micro Devices, Inc. All rights reserved.
+#
+# See LICENSE for license information.
+
+"""Render one sGPU queue run's scheduling report from its measured timings.
+
+"""
+
+import argparse
+import os
+import sys
+
+from queue_files import KILLED_RCS, read_timings
+from build_weights import item_key, read_weights
+
+# Where the scheduler puts things under its log directory
+TIMINGS_PATH = ("queue", "timings.tsv")
+QUEUE_PATH = ("queue", "queue.tsv")
+REPORT_PATH = ("report", "schedule.md")
+
+REPORT_TITLE = "sGPU queue schedule"
+
+
+def outcome(rc):
+    """An exit code as the word that says what to do about it.
+    """
+    if rc == 0:
+        return "pass"
+    if rc == 1:
+        return "fail"
+    return "killed" if rc in KILLED_RCS else "error"
+
+
+def read_queue_keys(path):
+    """Every item the queue intended to run, as "<label>/<tag>" keys.
+
+    queue.tsv columns are weight, label, cmd, tag, rest; an empty tag is an
+    opaque whole-suite item, which the timings file records as "whole".
+    """
+    keys = []
+    with open(path, encoding="utf-8") as handle:
+        for line in handle:
+            fields = line.rstrip("\n").split("\t")
+            if len(fields) >= 4:
+                keys.append(f"{fields[1]}/{fields[3] or 'whole'}")
+    return keys
+
+def render_md(rows):
+    """Rows as a GitHub-flavoured Markdown table."""
+    out = []
+    for n, row in enumerate(rows):
+        out.append("| " + " | ".join(c.replace("|", "\\|") for c in row) + " |")
+        if n == 0:
+            out.append("|" + "---|" * len(row))
+    return out
+
+def calculate_efficiency_table(frame, wall, n_gpus):
+    """What the run cost, and how much of the GPU-time it bought was used."""
+    work = int(frame["secs"].sum())
+    if len(frame):
+        biggest = frame.loc[frame["secs"].idxmax()]
+        big, bigname = int(biggest["secs"]), biggest["name"]
+    else:
+        big, bigname = 0, ""
+    # Once one item exceeds the per-GPU average there is no ordering that
+    # finishes sooner than that item, so it becomes the thing to split.
+    floor = " -- floor: splitting it would now pay" if big > work / n_gpus else ""
+    return [
+        ["Metric", "Value", "Meaning"],
+        ["total work", f"{work}s", f"sum of all {len(frame)} item durations"],
+        ["actual run time", f"{wall}s", "wall clock, first item start to last item finish"],
+        [
+            "utilisation",
+            f"{work * 100 / (wall * n_gpus):.1f}%",
+            f"share of {wall}s x {n_gpus} GPUs actually spent running tests",
+        ],
+        ["largest item", f"{big}s", bigname + floor],
+    ]
+
+
+def calculate_gpu_utilisation_table(frame, wall, gpu_ids):
+    """Per-GPU utilisation.
+    """
+    per_gpu = frame.groupby("gpu")
+    busy = per_gpu["secs"].sum().reindex(gpu_ids, fill_value=0).astype(int)
+    count = per_gpu.size().reindex(gpu_ids, fill_value=0).astype(int)
+    failed = (
+        frame[frame["rc"] != 0].groupby("gpu").size().reindex(gpu_ids, fill_value=0).astype(int)
+    )
+
+    return [["GPU", "Items", "Busy", "Idle", "Util", "Failed"]] + [
+        [
+            f"gpu{gpu}",
+            f"{count[gpu]}",
+            f"{busy[gpu]}s",
+            f"{wall - busy[gpu]}s",
+            f"{busy[gpu] * 100 / wall:.1f}%",
+            f"{failed[gpu]}",
+        ]
+        for gpu in gpu_ids
+    ]
+
+
+def calculate_schedule_table(frame, default_weight):
+    """What ran where, in execution order, against what it was estimated to cost."""
+    order = frame.assign(_gpu=frame["gpu"].astype(int)).sort_values(
+        ["_gpu", "start_off", "name"], kind="stable"
+    )
+    rows = [["GPU", "Start", "Duration", "Result", "Estimate", "% change", "Test name"]]
+    for row in order.itertuples(index=False):
+        known = row.est > 0 and row.est != default_weight
+        # The % change is the scheduler feedback loop made visible: a large
+        # positive miss is an item that should have been dispatched earlier.
+        change = f"{(row.secs - row.est) * 100 / row.est:+.0f}%" if known else "n/a"
+        # "cut" marks a duration that is where the item was stopped rather than
+        # what it costs, which is also why the next run's weight table ignores
+        # that row.
+        result = outcome(row.rc) + (" (cut)" if row.incomplete == 1 else "")
+        rows.append(
+            [
+                f"gpu{row.gpu}",
+                f"t+{row.start_off}s",
+                f"{row.secs}s",
+                result,
+                "unknown" if row.est == default_weight else f"{row.est}s",
+                change,
+                row.name,
+            ]
+        )
+    return rows
+
+
+def calculate_updated_weights_table(frame, weights, default_weight):
+    """
+    What the next run will schedule each item with.
+    """
+    rows = []
+    for row in frame.itertuples(index=False):
+        key = item_key(row.label, "" if row.tag == "whole" else row.tag)
+        new = weights.get(key)
+        known = row.est > 0 and row.est != default_weight
+        rows.append(
+            (
+                # An item the table does not name is one the next run has no
+                # weight for, and order_queue sorts those first -- so it sorts
+                # first here too, for the ordering claim above to hold.
+                new if new is not None else float("inf"),
+                [
+                    f"{new:.0f}s" if new is not None else "unknown",
+                    "unknown" if not known else f"{row.est}s",
+                    f"{row.secs}s" + (" (cut)" if row.incomplete == 1 else ""),
+                    f"{(row.secs - row.est) * 100 / row.est:+.0f}%" if known else "n/a",
+                    row.name,
+                ],
+            )
+        )
+    # Name breaks ties so the order is stable run to run rather than dependent on
+    # dispatch order.
+    rows.sort(key=lambda r: (-r[0], r[1][4]))
+    return [["Updated weight", "This run", "Current weight", "% change", "Test name"]] + [
+        row for _, row in rows
+    ]
+
+
+def missing_items(frame, queue_keys):
+    """Items the queue held that produced no timing record.
+
+    Only possible if a worker died outright, and silence here would read as
+    success.
+    """
+    seen = set(frame["name"])
+    return [key for key in queue_keys if key not in seen]
+
+
+# ---------------------------------------------------------------------------
+# Report.
+
+
+def render_report_md(frame, wall, gpu_ids, total_items, default_weight, missing, weights):
+    """The Markdown report the workflow appends to the job summary."""
+    n_gpus = len(gpu_ids)
+    ran = len(frame)
+    failed = int((frame["rc"] != 0).sum())
+    util = int(frame["secs"].sum()) * 100 / (wall * n_gpus)
+    mark = ":x:" if failed or ran != total_items else ":white_check_mark:"
+
+    out = [
+        f"## {REPORT_TITLE}",
+        "",
+        f"{mark} **{ran} items** on {n_gpus} GPUs -- {failed} failed "
+        f"-- {wall}s wall clock at {util:.1f}% GPU utilisation",
+        "",
+    ]
+
+    if ran != total_items:
+        out.append(f"> :warning: **Only {ran} of {total_items} items produced a timing")
+        out.append("> record.** The rest were never dispatched, which means a worker died:")
+        out.append("")
+        out.extend(f"> - `{key}`" for key in missing)
+        out.append("")
+
+    for heading, rows in (
+        ("Efficiency", calculate_efficiency_table(frame, wall, n_gpus)),
+        ("Per-GPU utilisation", calculate_gpu_utilisation_table(frame, wall, gpu_ids)),
+    ):
+        out += [f"### {heading}", ""] + render_md(rows) + [""]
+
+    # The two big tables are collapsed: they are the detail you open once you
+    # know from the sections above that something is worth looking at.
+    for summary, rows in (
+        (
+            "Schedule -- what ran where, in execution order",
+            calculate_schedule_table(frame, default_weight),
+        ),
+        (
+            "Updated weights for next run",
+            calculate_updated_weights_table(frame, weights, default_weight),
+        ),
+    ):
+        out += [f"<details><summary>{summary}</summary>", ""] + render_md(rows)
+        out += ["", "</details>", ""]
+    return out
+
+
+def main():
+    """Parse arguments, render the report, and never fail the run over it."""
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("log_dir", help="the queue's log directory, e.g. test-results/logs")
+    # Required, both of them: they are facts about the run that no file in the
+    # log directory records, and guessing at either yields a plausible-looking
+    # report with the wrong utilisation in it.
+    parser.add_argument(
+        "--gpus", required=True, metavar="IDS", help='space-separated device ids, e.g. "0 1 2 4"'
+    )
+    parser.add_argument(
+        "--wall", type=int, required=True, metavar="SECS", help="run wall clock in seconds"
+    )
+    parser.add_argument(
+        "--default-weight",
+        type=int,
+        default=999999,
+        help="the est value that means 'no weight was known'",
+    )
+    parser.add_argument(
+        "--weights",
+        required=True,
+        metavar="TABLE",
+        help="the weight table build_weights.py has just rewritten; the report "
+        "reads it to show what the next run will schedule with",
+    )
+    args = parser.parse_args()
+
+    timings = os.path.join(args.log_dir, *TIMINGS_PATH)
+    queue = os.path.join(args.log_dir, *QUEUE_PATH)
+    out = os.path.join(args.log_dir, *REPORT_PATH)
+    if not os.path.exists(timings):
+        print(f"no {timings}: nothing to report on", file=sys.stderr)
+        return 0
+
+    frame = read_timings(timings)
+
+    gpu_ids = args.gpus.split() or ["0"]
+    wall = max(args.wall, 1)
+
+    # Without queue.tsv there is nothing to say an item is missing, so every item
+    # that ran is taken to be every item there was.
+    queue_keys = read_queue_keys(queue) if os.path.exists(queue) else list(frame["name"])
+    missing = missing_items(frame, queue_keys)
+
+    weights = read_weights(args.weights)
+
+    report = render_report_md(
+        frame, wall, gpu_ids, len(queue_keys), args.default_weight, missing, weights
+    )
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    with open(out, "w", encoding="utf-8") as handle:
+        handle.write("\n".join(report) + "\n")
+
+    print(f"Scheduling report: {out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/.github/workflows/rocm-ci.yml b/.github/workflows/rocm-ci.yml
index 5591f1f399..b778a68359 100644
--- a/.github/workflows/rocm-ci.yml
+++ b/.github/workflows/rocm-ci.yml
@@ -182,7 +182,26 @@ jobs:
           EOF
           )"
 
-      - name: Run sGPU tests in parallel (pytorch, jax, examples, core)
+      # The scheduler orders its queue longest-first, so it needs a per-item cost
+      # estimate. That table is produced by the previous run of this same job and
+      # carried forward in the cache -- there is no separate measurement pass.
+      # `restore` and `save` are separate actions on purpose: `actions/cache`
+      # skips its implicit save when the job fails, and a failing test run is
+      # exactly when the timings are most worth keeping.
+      #
+      # The key carries the test level as well as the arch. A level decides both
+      # which items run and how long some of them take (tests/jax switches on
+      # NVTE_JAX_UNITTEST_LEVEL, test_grouped_gemm.py adds its real shapes at
+      # level 2), so a shared table would have L1 and L3 runs continually
+      # overwriting each other's weights for the same key with different numbers.
+      - name: Restore learned test weights
+        uses: actions/cache/restore@v4
+        with:
+          path: ci-weights
+          key: te-sgpu-weights-${{ matrix.arch_label }}-l${{ env.TEST_LEVEL }}-${{ github.run_id }}
+          restore-keys: te-sgpu-weights-${{ matrix.arch_label }}-l${{ env.TEST_LEVEL }}-
+
+      - name: Run sGPU tests as one queue (pytorch, jax, examples, core)
         id: run-tests
         # Below the job's timeout-minutes so an overrun kills only this step;
         # the `if: always()` report + upload steps still run (artifacts survive).
@@ -190,10 +209,24 @@ jobs:
         env:
           HF_TOKEN: ${{ secrets.HF_TOKEN }}
         run: |
-          # One subdir per suite so PyTorch/JAX/Core get independent reports and
-          # never collide on identically-named XML (e.g. test_sanity_import.auto.xml
-          # exists in both the torch and jax suites and runs in parallel).
-          rm -rf test-results && mkdir -p test-results/torch test-results/jax test-results/core
+          # The queue clears test-results/ itself and creates one XML subdir per
+          # suite, so PyTorch/JAX/Core get independent reports and never collide
+          # on identically-named XML (test_sanity_import.auto.xml exists in both
+          # the torch and jax suites and runs in parallel). Clearing it here too
+          # covers the case where the container never starts.
+          rm -rf test-results
+
+          # No in-tree seed table: on a cache miss the file is simply absent, the
+          # queue runs in its natural order for one run, and this run's timings
+          # create the table. A checked-in copy would go stale silently and is
+          # worth less than the one unordered run it saves.
+          #
+          # Listed rather than named: the queue derives the file from the arch it
+          # reads off rocminfo, and deriving it a second time from the matrix
+          # label would be a second thing to keep in step.
+          mkdir -p ci-weights
+          wc -l ci-weights/*.txt 2>/dev/null \
+            || echo "no weight table restored; this run will be unordered"
 
           docker exec \
             -e TEST_SGPU=1 \
@@ -201,10 +234,22 @@ jobs:
             -e JUNITXML_PREFIX=/workspace/test-results/ \
             -e JUNITXML_SUFFIX=.xml \
             -e HF_TOKEN="$HF_TOKEN" \
-            te-runner bash /workspace/.github/scripts/run_parallel_sgpu.sh \
-              --first-gpu 0 \
-              --log-dir /workspace/ \
-              /workspace/.github/scripts/ci_sgpu_jobs.conf
+            -e GITHUB_ACTIONS \
+            te-runner bash /workspace/.github/scripts/run_queue_sgpu.sh \
+              --log-dir /workspace/test-results/logs
+
+      # The queue's own last phase updated ci-weights/ before it exited, including
+      # when tests failed -- a red run still measures how long each item took. Only
+      # a run killed outright (this step's timeout) skips it, and that run's
+      # durations are ceilings imposed by the kill rather than costs, so losing
+      # them is no loss. Saving is separate because it must happen either way:
+      # a failed run's table is still better than the one restored above.
+      - name: Save learned test weights
+        if: always() && hashFiles('ci-weights/*') != ''
+        uses: actions/cache/save@v4
+        with:
+          path: ci-weights
+          key: te-sgpu-weights-${{ matrix.arch_label }}-l${{ env.TEST_LEVEL }}-${{ github.run_id }}
 
       - name: Generate test report
         if: always()
@@ -220,35 +265,59 @@ jobs:
           python3 ci/junit_report.py test-results/core \
             --title "sGPU Core (${{ matrix.arch_label }})"
 
+      # Last, so the summary leads with test results: how the work was scheduled
+      # only matters once you know what the tests did.
+      - name: Publish scheduling report
+        if: always()
+        run: |
+          if [ -f test-results/logs/report/schedule.md ]; then
+            cat test-results/logs/report/schedule.md >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "::warning::no schedule.md -- the queue did not reach its report phase"
+          fi
+
+      # The gate is per suite, as before -- the queue interleaves suites across
+      # GPUs, but a suite is still what "PyTorch tests failed" means. What is
+      # dumped inline is per item: only the item logs that actually ended non-zero,
+      # rather than the whole suite's output with the failure buried in it. The
+      # passing items are in the artifact for anyone who wants them.
       - name: Check suite failure status
         if: always()
         run: |
           EXIT_STATUS=0
-          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
+          while IFS= read -r line || [[ -n "$line" ]]; do
+            [[ "$line" =~ ^[[:space:]]*# ]] && continue
+            [[ -z "${line//[[:space:]]/}" ]] && continue
+            read -r label logfile rest <<< "$line"
+            rc=$(cat "test-results/logs/suites/${logfile}.rc" 2>/dev/null || echo "missing")
+            [[ "$rc" == "0" ]] && continue
+            echo "::error::${label} tests FAILED (rc=${rc})."
+            EXIT_STATUS=1
+            for f in test-results/logs/items/"${label}".*.log; do
+              [[ -e "$f" ]] || continue
+              irc=$(cat "${f}.rc" 2>/dev/null || echo 1)
+              [[ "$irc" == "0" ]] && continue
+              echo "::group::[FAILED] $(basename "$f" .log) (rc=${irc})"
+              cat "$f"
+              echo "::endgroup::"
+            done
+          done < .github/scripts/ci_sgpu_queue.conf
           exit $EXIT_STATUS
 
+      # test-results/ is the whole run: XML per suite plus one directory per
+      # scheduler phase under logs/. A download answers "what did it plan, what
+      # did it set up, what did each item print, what did each item cost" from a
+      # single tree. logs/queue/ is what makes it reproducible after the fact --
+      # schedule.md and the weight table can both be regenerated from
+      # timings.tsv + items.tsv alone.
       - name: Upload logs
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: logs-sgpu-${{ matrix.arch_label }}
           path: |
-            *.log
-            test-results/**/*.xml
+            test-results/**
+            ci-weights/*.txt
           if-no-files-found: ignore
           retention-days: 5
 
diff --git a/.gitignore b/.gitignore
index 940c43b720..563145f080 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,3 +64,5 @@ transformer_engine/common/util/hip_nvml.*
 .codex/
 .cline_storage/
 .claude/
+test-results/
+ci-weights/
diff --git a/ci/_utils.sh b/ci/_utils.sh
index f2478fc762..d01736f8ee 100644
--- a/ci/_utils.sh
+++ b/ci/_utils.sh
@@ -79,6 +79,7 @@ export PYTHONSAFEPATH=${PYTHONSAFEPATH:-1}
 _script_error_count=0
 _run_error_count=0
 _ignored_error_count=0
+_seen_test_tags=""
 TEST_ERROR_IGNORE=""
 
 script_error() {
@@ -139,6 +140,53 @@ check_level() {
     test $TEST_LEVEL -ge $1
 }
 
+# TE_CI_LIST_ALL widens list mode from "what this host would run" to "what this
+# TEST_LEVEL could run anywhere". Level gating, the backend matrix and TEST_FILTER
+# still apply -- only host capability probes are answered yes without probing.
+# The scheduler uses the wider list as the authoritative set of work items that
+# exist, so .github/scripts/scheduler/build_weights.py can tell a test that was deleted or
+# renamed (drop its weight) from one this host merely skipped (keep it). A probe
+# result varies by machine; whether a test file exists does not.
+check_list_all() {
+    test -n "$TE_CI_LIST_ONLY" -a -n "$TE_CI_LIST_ALL"
+}
+
+# Whether this invocation is the one that should do container-wide setup. The
+# scheduler hoists that out of the per-item runs -- once per suite with
+# TE_CI_SETUP_ONLY, then TE_CI_SKIP_SETUP on every item it dispatches -- and list
+# mode sets nothing up at all, since it only prints what it would have run. Every
+# setup step goes through here rather than spelling the condition out again.
+check_setup_needed() {
+    test -z "$TE_CI_SKIP_SETUP$TE_CI_LIST_ONLY"
+}
+
+# Every host capability probe goes through here, selected by label. Returns 0 to
+# run the guarded tests, 1 to skip them.
+check_supported() {
+    check_list_all && return 0
+    case "$1" in
+        "mxfp8")
+            #MXFP8-only test filters collect no tests on unsupported archs
+            _probe_result=$(NVTE_ROCM_ENABLE_MXFP8=1 python -c "${PYTHON_TE_IMPORT}; from transformer_engine.pytorch.quantization import is_mxfp8_available; print(is_mxfp8_available())" 2>/dev/null)
+            _probe_message="MXFP8 is not supported on this device, skipping MXFP8-only tests"
+        ;;
+        "flash_attn")
+            _probe_result=$(python -c "${PYTHON_TE_IMPORT}; from transformer_engine.pytorch.attention.dot_product_attention.utils import FlashAttentionUtils; print(FlashAttentionUtils.is_installed)" 2>/dev/null)
+            _probe_message="Flash attention is not installed"
+        ;;
+        *)
+            #A mistyped label must not read as "unsupported": that would skip the
+            #guarded tests on every host and look exactly like a machine that
+            #cannot run them. Count it so the run's exit code reports it.
+            script_error "check_supported: unknown capability $1"
+            return 1
+        ;;
+    esac
+    test "$_probe_result" = "True" && return 0
+    echo "$_probe_message" >&2
+    return 1
+}
+
 check_test_jobs_requested() {
     return 1 #Disable parallel jobs because some tests do not support parallel execution
     test -z "$SINGLE_CONFIG" -a -n "$TEST_JOBS" || return 1
@@ -311,6 +359,27 @@ check_test_filter() {
     return 1
 }
 
+# The test name tag names the JUnit XML file and is the TEST_FILTER key a
+# scheduler re-dispatches on, so two call lines may not share one: the second
+# would overwrite the first's results, and one dispatch would run both. Anything
+# that changes what a line runs -- an env prefix, a -k expression, extra pytest
+# args -- needs its own label to keep the tags apart.
+#
+# Fatal rather than counted-and-continued. Skipping the offending call line
+# leaves a run that looks complete but is quietly short by an item, and in list
+# mode that short list is what the scheduler queues -- so the tests the
+# duplicate displaced never run at all, on this run or any after it. The only
+# signal would be a non-zero exit code at the very end, long after the message
+# scrolled past.
+check_test_tag_unique() {
+    case " $_seen_test_tags " in
+    *" $1 "*)
+        script_error "Duplicate test tag $1: give the call site a distinct label"
+        exit 1
+    esac
+    _seen_test_tags="$_seen_test_tags $1"
+}
+
 start_message() {
     echo "Started with TEST_LEVEL=$TEST_LEVEL sGPU='$TEST_SGPU' mGPU='$TEST_MGPU' at `date`"
     _rocm_path=$(resolve_rocm_path)
@@ -350,6 +419,18 @@ pytest_run() {
     shift 3
     _test_name_tag=`get_test_name_tag $1 $_test_variant_tag`
     check_test_filter $_test_name_tag || return
+    check_test_tag_unique $_test_name_tag || return
+    # List mode: emit the work item instead of running it, so an external
+    # scheduler can pack items across GPUs. The tag alone is enough to
+    # re-dispatch the item: setting TEST_FILTER to it and re-entering this
+    # script replays the very same call line, so the inline NVTE_* prefixes and
+    # -k expressions are reapplied by the script itself and never have to be
+    # serialized here. The suite scripts stay the single source of truth for
+    # what runs at each TEST_LEVEL.
+    if [ -n "$TE_CI_LIST_ONLY" ]; then
+        echo "TE_CI_ITEM $_test_name_tag"
+        return
+    fi
     _start_ts=`date +%s`
     echo "Run [$_test_variant_tag] $@ at `time_elapsed $TEST_START_TS`"
     # A per-test timeout is applied to every item. Callers may still append their
@@ -384,7 +465,12 @@ pytest_run() {
 }
 
 PYTHON_TE_IMPORT="import sys; sys.path[:] = [p for p in sys.path if p not in ['', '.']]; import transformer_engine"
+# Usage: ck_jit_prebuild build|list
+# Build the CK JIT blob cache, or report what is in it. Like check_supported, the
+# guard lives with the thing it guards: a dispatched item or a list run returns
+# here without touching the cache, so no caller has to remember to ask.
 ck_jit_prebuild() {
+    check_setup_needed || return 0
     _prebuild_list="${TE_PATH}ci/ck_jit_prebuild.txt"
     if [ ! -f "$_prebuild_list" ]; then
         script_error "ck_jit_prebuild: blob list not found: $_prebuild_list"
diff --git a/ci/jax.sh b/ci/jax.sh
index dbca249c9b..403ef44e96 100755
--- a/ci/jax.sh
+++ b/ci/jax.sh
@@ -99,11 +99,11 @@ run_test_config_mgpu() {
     run_default_fa 2 test_distributed_layernorm_mlp.py -k "not (${_layernorm_mlp_jax_gemm_k})"
     _saved_xla_flags="$XLA_FLAGS"
     export XLA_FLAGS="${XLA_FLAGS} --xla_gpu_enable_triton_gemm=false"
-    run_default_fa 2 test_distributed_layernorm_mlp.py -k "${_layernorm_mlp_jax_gemm_k}"
+    run_default_fa_lbl "no_triton_gemm" 2 test_distributed_layernorm_mlp.py -k "${_layernorm_mlp_jax_gemm_k}"
     export XLA_FLAGS="$_saved_xla_flags"
     run_default_fa 3 test_distributed_softmax.py
 
-    run_default_fa 3 test_sanity_import.py
+    run_default_fa_lbl "mgpu" 3 test_sanity_import.py
 }
 
 # Single config mode, run it synchronously and return result
@@ -116,11 +116,17 @@ fi
 
 #Master script mode: prepares testing prerequisites
 start_message
-install_prerequisites
-pip list | egrep "flax|fidle|jax|ml_dtypes|numpy|transformer_e|typing_ext"
-#check_test_jobs_requested
-#test $? -eq 0 && init_test_jobs `python -c "import jax; print(len([d for d in jax.devices() if 'rocm' in d.client.platform_version]))"`
-ck_jit_prebuild build || exit $?
+#See ci/pytorch.sh for the TE_CI_SETUP_ONLY / TE_CI_SKIP_SETUP contract. Running
+#the CK JIT prebuild here once, sequentially, also removes the race this script
+#used to have with ci/pytorch.sh over the shared blob cache.
+if check_setup_needed; then
+    install_prerequisites
+    pip list | egrep "flax|fidle|jax|ml_dtypes|numpy|transformer_e|typing_ext"
+    #check_test_jobs_requested
+    #test $? -eq 0 && init_test_jobs `python -c "import jax; print(len([d for d in jax.devices() if 'rocm' in d.client.platform_version]))"`
+    ck_jit_prebuild build || exit $?
+    test -n "$TE_CI_SETUP_ONLY" && exit 0
+fi
 
 for _fus_attn in auto ck aotriton; do
     configure_fused_attn_env $_fus_attn || continue
diff --git a/ci/pytorch.sh b/ci/pytorch.sh
index 38cef08ce6..2d40f5e5e9 100755
--- a/ci/pytorch.sh
+++ b/ci/pytorch.sh
@@ -38,17 +38,6 @@ run_default_fa_lbl() {
     fi
 }
 
-check_mxfp8_supported() {
-    #Guard MXFP8-only test filters, which collect no tests on unsupported archs
-    _result=$(NVTE_ROCM_ENABLE_MXFP8=1 python -c "${PYTHON_TE_IMPORT}; from transformer_engine.pytorch.quantization import is_mxfp8_available; print(is_mxfp8_available())" 2>/dev/null)
-    if [ "$_result" = "True" ]; then
-        return 0
-    else
-        echo "MXFP8 is not supported on this device, skipping MXFP8-only tests" >&2
-        return 1
-    fi
-}
-
 run_test_config(){
     echo ==== Run with Fused attention backend: $_fus_attn ====
     #_WORKERS_COUNT=$TEST_WORKERS
@@ -56,10 +45,22 @@ run_test_config(){
     export NVTE_GROUPED_LINEAR_SINGLE_PARAM=1
     run_default_fa 1 test_backward_override.py
     if [ $_fus_attn = "$_DEFAULT_FUSED_ATTN" ]; then
-        mkdir -p ${TEST_DIR}/checkpoint
-        python ${TEST_DIR}/test_checkpoint.py --save-checkpoint all --checkpoint-dir ${TEST_DIR}/checkpoint
-        NVTE_TEST_CHECKPOINT_ARTIFACT_PATH=${TEST_DIR}/checkpoint run 1 test_checkpoint.py
-        rm -rf ${TEST_DIR}/checkpoint
+        #The checkpoint artifact is generated outside pytest_run, so it is not
+        #covered by TEST_FILTER. Gate it on the same tag the test itself uses,
+        #otherwise every filtered invocation regenerates the artifact -- and
+        #concurrent ones race on the shared checkpoint directory.
+        _ckpt_variant=`get_test_variant_tag $_fus_attn ""`
+        _ckpt_tag=`get_test_name_tag test_checkpoint.py $_ckpt_variant`
+        if [ -n "$TE_CI_LIST_ONLY" ]; then
+            #Only emit the work item; do not generate the artifact. Save, test
+            #and cleanup stay one unit when the item is dispatched.
+            run 1 test_checkpoint.py
+        elif check_test_filter "$_ckpt_tag"; then
+            mkdir -p ${TEST_DIR}/checkpoint
+            python ${TEST_DIR}/test_checkpoint.py --save-checkpoint all --checkpoint-dir ${TEST_DIR}/checkpoint
+            NVTE_TEST_CHECKPOINT_ARTIFACT_PATH=${TEST_DIR}/checkpoint run 1 test_checkpoint.py
+            rm -rf ${TEST_DIR}/checkpoint
+        fi
     fi
     run 1 test_cuda_graphs.py
     run_default_fa 1 test_deferred_init.py
@@ -78,7 +79,7 @@ run_test_config(){
     run 1 test_jit.py
     NVTE_ROCM_ENABLE_MXFP8=1 run_default_fa 1 test_multi_tensor.py
     run 1 test_numerics.py
-    check_mxfp8_supported && NVTE_ROCM_ENABLE_MXFP8=1 run_default_fa_lbl "mxfp8" 1 test_numerics.py -k "MXFP8BlockScaling and 126m and not grouped"
+    check_supported mxfp8 && NVTE_ROCM_ENABLE_MXFP8=1 run_default_fa_lbl "mxfp8" 1 test_numerics.py -k "MXFP8BlockScaling and 126m and not grouped"
     run_default_fa 1 test_nvfp4_fsdp2_hooks.py
     run_default_fa 1 test_permutation.py
     run_default_fa 1 test_recipe.py
@@ -117,7 +118,7 @@ run_test_config_mgpu(){
     #this test is not really mGPU but time sensitive so run it here because sGPU tests
     #run in parallel on CI and it affects timing
     run_default_fa 1 test_gemm_sm_count.py
-    run_default_fa 3 test_sanity_import.py
+    run_default_fa_lbl "mgpu" 3 test_sanity_import.py
     run_default_fa 3 distributed/test_cast_master_weights_to_fp8.py
     run_default_fa 3 distributed/test_comm_gemm_overlap.py
     run_default_fa 2 distributed/test_fusible_ops.py
@@ -133,6 +134,10 @@ run_test_config_mgpu(){
 
 run_benchmark() {
     check_test_filter benchmark || return
+    if [ -n "$TE_CI_LIST_ONLY" ]; then
+        echo "TE_CI_ITEM benchmark"
+        return
+    fi
     echo "\n============= Running benchmarks attention script ============="
     BENCH_SCRIPT="$DIR/../benchmarks/attention/benchmark_attention_rocm.py"
     
@@ -156,22 +161,18 @@ if [ -n "$SINGLE_CONFIG" ]; then
     exit $?
 fi
 
-check_flash_attn_installed() {
-    _result=$(python -c "${PYTHON_TE_IMPORT}; from transformer_engine.pytorch.attention.dot_product_attention.utils import FlashAttentionUtils; print(FlashAttentionUtils.is_installed)" 2>/dev/null)
-    if [ "$_result" = "True" ]; then
-        return 0
-    else
-        echo "Flash attention is not installed" >&2
-        return 1
-    fi
-}
-
 #Master script mode: prepare testing prerequisites first
 start_message
-install_prerequisites
-pip list | egrep "flash|ml_dtypes|numpy|torch|transformer_e|typing_ext"
-#check_test_jobs_requested && init_test_jobs `python -c "import torch; print(torch.cuda.device_count())"`
-ck_jit_prebuild build || exit $?
+#Prerequisites and the CK JIT cache are container-wide state, so a scheduler
+#that dispatches many TEST_FILTER-ed invocations does them once up front with
+#TE_CI_SETUP_ONLY and then passes TE_CI_SKIP_SETUP on every item.
+if check_setup_needed; then
+    install_prerequisites
+    pip list | egrep "flash|ml_dtypes|numpy|torch|transformer_e|typing_ext"
+    #check_test_jobs_requested && init_test_jobs `python -c "import torch; print(torch.cuda.device_count())"`
+    ck_jit_prebuild build || exit $?
+    test -n "$TE_CI_SETUP_ONLY" && exit 0
+fi
 
 for _fus_attn in auto flash ck aotriton unfused; do
     configure_fused_attn_env $_fus_attn || continue
@@ -195,7 +196,7 @@ for _fus_attn in auto flash ck aotriton unfused; do
     fi
 
     if [ $_fus_attn = flash ]; then
-        check_flash_attn_installed || continue
+        check_supported flash_attn || continue
     fi
 
     if [ -n "$TEST_JOBS_MODE" ]; then