Auto-file GitHub issues for nightly UT new failures

New failures in the nightly UT run are today only visible as a red job and a
CSV artifact, and muting one means a human hand-writing a skip issue. This adds
a deterministic bot that files one issue per root cause, plus the artifacts it
needs from the existing UT pipeline.

Filing an issue mutes a test: fetch_issues.sh subtracts the `Cases:` block of
every open `skipped` issue from the next night's failures. Every decision here
therefore fails in the direction of leaving a case running rather than silently
muting it, and the job stays in --dry-run until the repo variable
UT_AUTO_ISSUE_ENABLED is set to `true`.

Review in this order:

1. The producers. These only add artifacts and change no existing behaviour:
   check-ut.py writes all_cases_<category>.log (the full case universe, which
   unlike passed+failures also carries skipped cases), ut_result_check.sh
   records its per-category count verdict to run_health.jsonl, and the two
   composite actions land collect_env.log and versions.txt under ut_log so the
   shas actually under test travel with the artifact.
2. The wiring: _linux_ut.yml exports UT_RUN_HEALTH_FILE, _ut_auto_issue.yml is
   a new callable workflow, and nightly_ondemand.yml calls it after the UT
   matrix - on !cancelled() rather than success(), since the UT job fails
   exactly when there is something to file.
3. ut_auto_issue.py. Its stage banners, Stage 0 through Stage 8, are the
   intended reading order.
4. ut-auto-issue-body.md, whose `Cases:` block and trailing marker are both
   machine-consumed; its header comment says which consumer reads what.

Three choices had a real alternative and are worth calling out.

Grouping keys on (normalized error, test file) rather than on the error alone.
The error alone would collapse a generic message - a precision mismatch, or the
sentinel used when a case dies without one - across unrelated files into a
single issue and therefore a single very wide mute. Over-splitting is the safe
direction, so one root cause spread over several files stays several issues,
and they are linked to each other by a comment instead of being merged.

The baseline is resolved per category, not per run. There is no "last good
nightly", only "the last nightly in which this category completed healthily":
a run that truncated in op_ut is still a perfectly good op_extended baseline.

The per-run issue cap admits or defers a whole error family at once. A plain
head/tail cut on the size-ordered list would file the big test files of one
root cause and defer its small ones, muting half a bug and leaving the rest to
fail every night.

Test Plan

No automated test ships with this change, so the pre-enable dry run below is
the gate, not a formality.

During development the pure logic was exercised against stubbed inputs -
normalization stability across nights, grouping, the family-atomic issue
budget, the Cases: parse/append contract that does the actual muting, and a
main() smoke test with every gh call replaced by a stub. Those harnesses were
ad hoc and are not part of the change.

Before UT_AUTO_ISSUE_ENABLED is set, the job must be dry-run against real past
nightlies and the rendered bodies in the report artifact reviewed by hand; the
normalization rules are the part most likely to need tuning:

```bash
python3 .github/scripts/ut_auto_issue.py --run-id <past_nightly_run_id> --dry-run
```

That command was not executed here: this workstation has no authenticated gh
and the script needs a real run id. The workflow's own default is --dry-run, so
merging this changes no issue state until the repo variable is set.

Authored with the assistance of an AI coding agent.

Author: RUIJIEZHONG66166

.github/ISSUE_TEMPLATE/agent/ut-auto-issue-body.md

@@ -0,0 +1,38 @@
+<!--
+Body template for issues filed by .github/scripts/ut_auto_issue.py.
+Placeholders use Python str.format() syntax: {field_name}. Every slot is filled
+with a fully pre-rendered string, so add no literal braces to this file.
+
+The shape mirrors issue #5070. Two parts are load-bearing and must not change
+without updating their consumers:
+
+  * The `Cases:` block is parsed by fetch_issues.sh plus the awk filter in
+    _linux_ut.yml. It must start with a line containing `Cases:`, carry one
+    `<category>,<class name>,<test name>` line per case with no blank lines in
+    between, and never be truncated - an incomplete block silently fails to
+    skip the case. The cases:begin/end markers bound the region the bot is
+    allowed to append to on a re-sighting.
+  * The trailing ut-auto-issue marker carries the grouping signature and is how
+    the bot recognises its own issues. Editing it will cause a duplicate issue.
+
+Everything else is for humans and is safe to edit by hand.
+-->
+### 🐛 Describe the bug with skip template
+
+<!-- cases:begin -->
+Cases:
+{cases}
+<!-- cases:end -->
+
+{error_log}## Pytorch Version
+
+{version_block}
+{evidence_block}### Versions
+
+<details><summary>Detail</summary>
+
+{collect_env}
+
+</details>
+
+<!-- {marker} -->

.github/actions/linux-testenv/action.yml

@@ -233,7 +233,16 @@ runs:
         python -c "import torchvision; print(torchvision.__version__)"
         python -c "import torchaudio; print(torchaudio.__version__)"
         python -c "import triton; print(triton.__version__)"
-        python pytorch/torch/utils/collect_env.py
+        # Land the environment and the exact shas under test in ut_log so they
+        # ride along in the UT artifact; ut_auto_issue.py reads them to render
+        # the issue body and to build baseline..current compare links.
+        mkdir -p "${{ github.workspace }}/ut_log"
+        python pytorch/torch/utils/collect_env.py |tee "${{ github.workspace }}/ut_log/collect_env.log"
+        # collect_env only carries an abbreviated torch sha and no torch-xpu-ops sha.
+        printf 'torch=%s\ntorch_xpu_ops=%s\n' \
+          "${TORCH_COMMIT_ID}" \
+          "$(git -C pytorch/third_party/torch-xpu-ops rev-parse HEAD 2>/dev/null || echo unknown)" \
+          > "${{ github.workspace }}/ut_log/versions.txt"
         uv pip list |grep -E 'torch|intel'
         TORCH_CHECK_ID=$(python -c 'import torch; print(torch.version.git_version)')
         if [ "${TORCH_CHECK_ID}" != "${TORCH_COMMIT_ID}" ];then

.github/actions/linux-uttest/action.yml

@@ -201,6 +201,14 @@ runs:
         else
           echo -e "No Passed logs"
         fi
+        # Copied the full case universe (includes skipped cases), used by
+        # ut_auto_issue.py to classify a failure against its baseline.
+        if ls all_cases_*.log 1> /dev/null 2>&1; then
+          cp all_cases_*.log ${{ github.workspace }}/ut_log
+          echo -e "All-cases logs Copied"
+        else
+          echo -e "No All-cases logs"
+        fi
         # Copied the Summary logs
         if ls category*.log 1> /dev/null 2>&1; then
           cp category*.log ${{ github.workspace }}/ut_log

.github/scripts/check-ut.py

@@ -15,6 +15,10 @@
 failures_by_category = defaultdict(list)
 passed_cases = []
 passed_by_category = defaultdict(list)
+# Every case seen, whatever its status. passed/failures alone cannot express
+# "skipped", which ut_auto_issue.py needs to tell a newly-enabled case from a
+# brand-new one.
+all_by_category = defaultdict(list)
 category_totals = defaultdict(lambda: {
     'Test cases': 0,
     'Passed': 0,
@@ -234,6 +238,7 @@ def parse_log_file(log_file):
         }
         failures.append(failure_case)
         failures_by_category[category].append(failure_case)
+        all_by_category[category].append(failure_case)
         failures_number += 1
 
     if failures_number > summary['Failures']:
@@ -299,11 +304,11 @@ def process_xml_file(xml_file):
             category_totals[category]['Errors'] += suite_summary['Errors']
 
             for case in suite:
+                case._file_category = category
+                all_by_category[category].append(case)
                 if get_result(case) not in ["passed", "skipped"]:
-                    case._file_category = category
                     failures.append(case)
                 elif get_result(case) == "passed":
-                    case._file_category = category
                     passed_cases.append(case)
                     passed_by_category[category].append(case)
     except Exception as e:
@@ -325,6 +330,19 @@ def generate_passed_log():
                 status = get_result(case)
                 log_file.write(f"{category},{class_name},{test_name}\n")
 
+def generate_all_cases_log():
+    """Full case universe per category, including skipped cases."""
+    for category, cases in all_by_category.items():
+        if not cases:
+            continue
+
+        log_filename = f"all_cases_{category}.log"
+        with open(log_filename, "w", encoding='utf-8') as log_file:
+            for case in cases:
+                class_name = get_classname(case)
+                test_name = get_name(case)
+                log_file.write(f"{category},{class_name},{test_name}\n")
+
 def generate_category_totals_log():
     """Generate log files with category totals"""
     for category, totals in category_totals.items():
@@ -390,6 +408,7 @@ def main():
 
     generate_failures_log()
     generate_passed_log()
+    generate_all_cases_log()
     generate_category_totals_log()
     print_summary()