From d6a9403348ad693d9bc258c7b63f0aa7a5a63b9f Mon Sep 17 00:00:00 2001
From: Ngo Quoc Dat <datlechin@gmail.com>
Date: Sat, 17 Oct 2026 23:06:38 +0700
Subject: [PATCH] ci: parse xcresult bundles in one place

---
 .claude/rules/ci.md                           |   7 +-
 .../references/verification-apple.md          |   4 +-
 .../fix-issue/scripts/lib/platform-apple.sh   | 132 +------
 .github/workflows/repo-hygiene.yml            |   1 +
 scripts/ci/summarize-xcresult.sh              | 145 +-------
 scripts/lib/test_xcresult_cases.py            | 331 ++++++++++++++++++
 scripts/lib/xcresult-cases.py                 | 270 ++++++++++++++
 7 files changed, 626 insertions(+), 264 deletions(-)
 create mode 100644 scripts/lib/test_xcresult_cases.py
 create mode 100755 scripts/lib/xcresult-cases.py

diff --git a/.claude/rules/ci.md b/.claude/rules/ci.md
index ae849a2d6d..f272d1feaf 100644
--- a/.claude/rules/ci.md
+++ b/.claude/rules/ci.md
@@ -50,9 +50,10 @@ The required check names are in `AGENTS.md` (CI). Reading a red check: `.claude/
 
 ## Summaries (`scripts/ci/summarize-xcresult.sh`)
 
+- Runs `scripts/lib/xcresult-cases.py summary`. `verify.sh` reads its verdicts through the same parser, and `scripts/lib/test_xcresult_cases.py` tests it in Repo Hygiene.
 - Reads `.xcresult` bundles and `swift test` xunit files, and skips a missing input.
-- Writes build errors with file and line, per-bundle counts and minutes, up to 50 failed cases and the 20 slowest to the step summary.
-- Exits 1 when a bundle or a `swift test` run executed nothing, because `xcodebuild` and `swift test` both call that success.
+- Writes build errors with file and 1-based line, runner failures ("System Failures"), per-bundle counts and minutes, up to 50 failed cases and the 20 slowest to the step summary.
+- Exits 1 when a bundle or a `swift test` run executed nothing, because `xcodebuild` and `swift test` both call that success. A runner failure is not an executed test.
 - For `X.xml` it also reads `X-swift-testing.xml`.
 - It never fails on a failed case; the test step already did.
 
@@ -73,7 +74,7 @@ The required check names are in `AGENTS.md` (CI). Reading a red check: `.claude/
 - Steps, in order:
   - actionlint, which also shellchecks every inline `run:` block;
   - `shellcheck --severity=warning` on every `*.sh` under `scripts` and `.claude/skills`;
-  - the tooling tests: `scripts/ci/test_*.py`, `scripts/test_localization.py`, `.github/scripts/test_update_registry.py` and two shell tests;
+  - the tooling tests: `scripts/ci/test_*.py`, `scripts/lib/test_*.py`, `scripts/test_localization.py`, `.github/scripts/test_update_registry.py` and two shell tests;
   - `check-lib-sourcing.py`, `check-plugin-manifest.py`, `check-deployment-target.sh`, `check-ios-shared-isolation.py`;
   - `localization.py plugins` and `plugins --target ios`;
   - `check-string-catalogs.py`, `check-license-inventory.py`, `check-entitlements.py`, `check-test-plans.py`;
diff --git a/.claude/skills/fix-issue/references/verification-apple.md b/.claude/skills/fix-issue/references/verification-apple.md
index e63300c7be..c97869cd76 100644
--- a/.claude/skills/fix-issue/references/verification-apple.md
+++ b/.claude/skills/fix-issue/references/verification-apple.md
@@ -33,7 +33,7 @@ Read this when a verdict, a test name or a red CI check needs explaining. The co
 
 ## Verdicts
 
-- A test verdict comes from the result bundle or the xunit file, never the console banner.
+- A test verdict comes from the result bundle or the xunit file, never the console banner. `scripts/lib/xcresult-cases.py` reads both, as it does for the CI summary.
 - The result-bundle rules, first match wins:
   1. nothing executed and the bundle holds build errors: FAIL, "the test build failed";
   2. nothing executed and `xcodebuild` exited nonzero: FAIL;
@@ -99,7 +99,7 @@ Read this when a verdict, a test name or a red CI check needs explaining. The co
 ## Reading CI
 
 - Artifacts exist only for a failed job and are kept 7 days. `macos-tests-<attempt>` holds every `.xcresult` plus `app-diagnostics` (TablePro crash reports and 2 hours of its unified log); `ios-tests-<attempt>` holds `iOS.xcresult`.
-- The step summary lists build errors, failed cases and the slowest cases (`.claude/rules/ci.md`, Summaries). A case that passed only on the UI plan's retry shows as a `Passed only on retry` warning annotation while the job stays green.
+- The step summary lists build errors, runner failures, failed cases and the slowest cases (`.claude/rules/ci.md`, Summaries). A case that passed only on the UI plan's retry shows as a `Passed only on retry` warning annotation while the job stays green.
 - `xcbeautify` can hide a compiler error behind "exit code 65". Read the check-run annotations, which also work while the run is going: `gh api repos/TableProApp/TablePro/check-runs/<job-id>/annotations`. Or open `Build.xcresult` from the artifact.
 - UI evidence: `gh run download <run-id> -n macos-tests-<attempt>`, then `xcrun xcresulttool get test-results activities --test-id <id> --path UI.xcresult` and `xcrun xcresulttool export attachments --path UI.xcresult --output-path <dir>`. The `element-tree-<n>` attachment shows which window held focus; the recording and the Synthesized Event plists show where each event landed.
 - A long silent stretch in the build log is a target's emit-module job, not a stall.
diff --git a/.claude/skills/fix-issue/scripts/lib/platform-apple.sh b/.claude/skills/fix-issue/scripts/lib/platform-apple.sh
index ab6c93d2a9..581b1e4160 100644
--- a/.claude/skills/fix-issue/scripts/lib/platform-apple.sh
+++ b/.claude/skills/fix-issue/scripts/lib/platform-apple.sh
@@ -39,7 +39,7 @@ diagnose_environment() {
         found=0
     fi
     if grep -q 'Unable to open base configuration reference file' "$log" 2> /dev/null; then
-        note "cause: Secrets.xcconfig is missing from this checkout. A fresh worktree needs it symlinked from the main checkout."
+        note "cause: the generated project names an xcconfig this checkout lacks. Rerun scripts/generate-project.sh (verify.sh generate)."
         found=0
     fi
     if grep -q 'The test runner hung before establishing connection' "$log" 2> /dev/null; then
@@ -207,111 +207,23 @@ test_regex() {
 
 # ---------------------------------------------------------------------------- test results
 
-# Every test case in a result bundle as "<target>/<suite>/<case><TAB><result><TAB>retried?". A runner
-# that crashed or never started is reported as a case under "System Failures"; it is not a test.
-xcresult_cases() {
-    xcrun xcresulttool get test-results tests --path "$1" --compact 2> /dev/null | jq -r '
-        [.. | objects | select((.nodeType // "") | endswith("test bundle"))][] | .name as $target
-        | .children[]? | (.nodeType == "Test Suite" and .name == "System Failures") as $system
-        | .. | objects | select(.nodeType == "Test Case")
-        | [ "\($target)/\(.nodeIdentifier // .name)", (if $system then "System Failure" else .result end),
-            (if .result == "Passed" and any(.children[]?; .nodeType == "Repetition" and .result == "Failed")
-             then "retried" else "" end) ] | @tsv'
-}
-
-# Every test case in swift test's xunit files as "<target>.<suite>/<case><TAB><result>".
-xunit_cases() {
-    local file
-    for file in "$@"; do
-        [ -f "$file" ] || continue
-        xmllint --format "$file" 2> /dev/null | awk '
-            function attr(line, name,    v) {
-                if (!match(line, " " name "=\"[^\"]*\"")) return ""
-                v = substr(line, RSTART + length(name) + 3, RLENGTH - length(name) - 4)
-                gsub(/&quot;/, "\"", v); gsub(/&apos;/, "\047", v)
-                gsub(/&lt;/, "<", v); gsub(/&gt;/, ">", v); gsub(/&amp;/, "\\&", v)
-                return v
-            }
-            function flush() { if (open) print key "\t" state; open = 0 }
-            /<testcase[ >]/ {
-                flush()
-                # A nested Swift Testing suite comes as Target.Outer.Inner; its filters use Outer/Inner.
-                cls = attr($0, "classname"); dot = index(cls, ".")
-                if (dot) { rest = substr(cls, dot + 1); gsub(/\./, "/", rest); cls = substr(cls, 1, dot) rest }
-                key = cls "/" attr($0, "name"); state = "Passed"; open = 1
-                if ($0 ~ /\/>[[:space:]]*$/) flush()
-                next
-            }
-            open && /<skipped/ { state = "Skipped" }
-            open && /<(failure|error)[ >\/]/ { state = "Failed" }
-            /<\/testcase>/ { flush() }
-            END { flush() }'
-    done
-}
-
-# Tallies a case list against the run's filters ("<label><TAB><regex>[<TAB>...]"). Prints the notes,
-# then a last line "<executed> <failed> <filters that ran nothing> <runner failures>".
-tally_cases() {
-    local cases="$1" filters="$2" sep="$3"
-    awk -F'\t' -v sep="$sep" '
-        FILENAME == ARGV[1] { if ($0 != "") { n++; label[n] = $1; re[n] = $2 }; next }
-        $0 == "" { next }
-        {
-            target = $1
-            cut = index(target, sep)
-            if (cut) target = substr(target, 1, cut - 1)
-            if ($2 == "System Failure") { runner++; next }
-            if (!(target in seen)) { seen[target] = 1; order[++targets] = target }
-            if ($2 == "Skipped") { skipped++; tskipped[target]++; next }
-            executed++; tran[target]++
-            if ($2 == "Passed") passed++
-            else if ($2 == "Failed") failed++
-            else expected++
-            if ($3 == "retried") retried[++nretried] = $1
-            for (i = 1; i <= n; i++) if ($1 ~ re[i]) hits[i]++
-        }
-        END {
-            line = "tests: " executed + 0 " executed, " passed + 0 " passed, " failed + 0 " failed, " skipped + 0 " skipped"
-            if (expected) line = line ", " expected " expected failures"
-            if (runner) line = line ", " runner " runner failures"
-            print line
-            if (targets) {
-                line = "targets:"
-                for (i = 1; i <= targets; i++) {
-                    t = order[i]
-                    line = line (i > 1 ? "," : "") " " t " " tran[t] + 0
-                    if (tskipped[t]) line = line " (" tskipped[t] " skipped)"
-                }
-                print line
-            }
-            zero = 0
-            for (i = 1; i <= n; i++) if (!hits[i]) { zero++; print "ran nothing: " label[i] }
-            if (nretried) {
-                print "passed only on retry, a flake to fix:"
-                for (i = 1; i <= nretried; i++) print "  " retried[i]
-            }
-            print executed + 0, failed + 0, zero, runner + 0
-        }' "$filters" "$cases"
-}
+# Beside this script, not under --root, so the parser always matches the tally format read here.
+XCRESULT_CASES="$SCRIPT_DIR/../../../../scripts/lib/xcresult-cases.py"
 
-# Sets RUN_EXECUTED, RUN_FAILED, RUN_ZERO and RUN_SYSTEM from a case list, and notes the tallies.
+# Sets RUN_EXECUTED, RUN_FAILED, RUN_ZERO and RUN_SYSTEM from the cases in a result bundle or xunit
+# file, counted against the run's filters ("<label><TAB><regex>[<TAB>...]"), and notes the tallies.
 apply_tally() {
-    local out counts
-    out="$(tally_cases "$@")"
-    counts="$(tail -1 <<< "$out")"
-    read -r RUN_EXECUTED RUN_FAILED RUN_ZERO RUN_SYSTEM <<< "$counts"
+    local filters="$1" input="$2" out
+    out="$(python3 "$XCRESULT_CASES" tally --filters "$filters" "$input")" \
+        || out="cause: scripts/lib/xcresult-cases.py failed, so no case was read."$'\n'"0 0 0 0"
+    read -r RUN_EXECUTED RUN_FAILED RUN_ZERO RUN_SYSTEM <<< "$(tail -1 <<< "$out")"
     note "$(sed '$d' <<< "$out")"
 }
 
 # Build errors with their file and line, which the result bundle keeps even when the log interleaves them.
 report_build_errors() {
     local errors
-    errors="$(xcrun xcresulttool get build-results --path "$1" --compact 2> /dev/null | jq -r '
-        .errors[]? | select(.message | startswith("Testing cancelled") | not)
-        | if .sourceURL then
-            (.sourceURL | capture("^file://(?<path>[^#]*)#.*StartingLineNumber=(?<line>[0-9]+)")) as $at
-            | "\($at.path | split("/") | last):\($at.line | tonumber + 1): \(.message)"
-          else .message end' | head -12)"
+    errors="$(python3 "$XCRESULT_CASES" errors "$1" | head -12)"
     [ -n "$errors" ] || return 1
     note "errors:"
     note "$(sed 's/^/  /' <<< "$errors")"
@@ -319,15 +231,8 @@ report_build_errors() {
 
 # The result bundle is the verdict. The log only explains a run that left no tests in it.
 report_xcresult() {
-    local bundle="$1" code="$2" filters="$3" log="$4" cases
-    cases="${bundle%.xcresult}.cases"
-    xcresult_cases "$bundle" > "$cases"
-    apply_tally "$cases" "$filters" /
-    rm -f "$cases"
-    if [ "$RUN_FAILED" -gt 0 ] || [ "$RUN_SYSTEM" -gt 0 ]; then
-        note "$(xcrun xcresulttool get test-results summary --path "$bundle" --compact 2> /dev/null | jq -r '
-            .testFailures[:10][] | "  \(.targetName)/\(.testIdentifierString): \(.failureText | split("\n")[0])"')"
-    fi
+    local bundle="$1" code="$2" filters="$3" log="$4"
+    apply_tally "$filters" "$bundle"
     if [ "$RUN_EXECUTED" -eq 0 ] && [ "$RUN_FAILED" -eq 0 ] && [ "$RUN_SYSTEM" -eq 0 ] && report_build_errors "$bundle"; then
         RUN_STATUS=FAIL
         note "cause: the test build failed, so no test ran."
@@ -353,12 +258,9 @@ report_xcresult() {
 }
 
 report_xunit() {
-    local log="$1" code="$2" filters="$3" xunit="${1%.log}.xml" cases
+    local log="$1" code="$2" filters="$3" xunit="${1%.log}.xml"
     note "results: $xunit"
-    cases="${log%.log}.cases"
-    xunit_cases "$xunit" "${xunit%.xml}-swift-testing.xml" > "$cases"
-    apply_tally "$cases" "$filters" .
-    rm -f "$cases"
+    apply_tally "$filters" "$xunit"
     if [ "$code" -ne 0 ] || [ "$RUN_FAILED" -gt 0 ]; then
         RUN_STATUS=FAIL
         note "$(report_errors "$log")"
@@ -533,6 +435,7 @@ platform_step() {
             [ "$STEP" = "uitest" ] && plan=UI other=test
             require_tool jq
             require_tool git
+            require_tool python3
             [ -f "$REPO_ROOT/TestPlans/$plan.xctestplan" ] || { echo "no TestPlans/$plan.xctestplan in $REPO_ROOT" >&2; exit 3; }
             TEST_TARGETS="$(test_targets_table)"
             plan_tests="" swift_tests="" packages=""
@@ -578,7 +481,6 @@ platform_step() {
             fi
             for package in $packages; do
                 require_tool swift
-                require_tool xmllint
                 # The first run writes the step's own log; each later one gets its own beside it.
                 if [ -z "$run_log" ]; then
                     run_log="$log"
@@ -643,7 +545,7 @@ platform_step() {
             STEP_DETAIL="$1${2:+ --filter $2}"
             setup_toolchain
             require_tool swift
-            require_tool xmllint
+            require_tool python3
             log="$(new_log "package-$1")"
             : > "${log%.log}.filters"
             [ $# -ge 2 ] && printf '%s\t%s\n' "$2" "$2" > "${log%.log}.filters"
@@ -657,7 +559,7 @@ platform_step() {
             STEP_DETAIL="TableProMobileTests: $*"
             setup_toolchain
             require_tool xcodebuild
-            require_tool jq
+            require_tool python3
             wait_for_free_toolchain
             name="$(printf '%s' "$1" | tr -c 'A-Za-z0-9_-' '_')"
             log="$(new_log "ios-$name")"
diff --git a/.github/workflows/repo-hygiene.yml b/.github/workflows/repo-hygiene.yml
index fb0825d0a1..1a4d9387da 100644
--- a/.github/workflows/repo-hygiene.yml
+++ b/.github/workflows/repo-hygiene.yml
@@ -47,6 +47,7 @@ jobs:
         run: |
           set -euo pipefail
           python3 -m unittest discover -s scripts/ci -p 'test_*.py'
+          python3 -m unittest discover -s scripts/lib -p 'test_*.py'
           python3 -m unittest discover -s scripts -p 'test_localization.py'
           python3 .github/scripts/test_update_registry.py
           bash scripts/ci/test_create_dmg_args.sh
diff --git a/scripts/ci/summarize-xcresult.sh b/scripts/ci/summarize-xcresult.sh
index 99763511f9..39cd16f323 100755
--- a/scripts/ci/summarize-xcresult.sh
+++ b/scripts/ci/summarize-xcresult.sh
@@ -1,149 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# Writes build errors, test counts and the slowest cases to $GITHUB_STEP_SUMMARY, or stdout.
 # Usage: summarize-xcresult.sh <bundle.xcresult | swift-test-xunit.xml>...
-#
-# Exits 1 when a test bundle, or a swift test run, executed no test: xcodebuild and swift test both
-# report that as success. A missing input is skipped, since its step did not run. For X.xml it also
-# reads X-swift-testing.xml, the file swift test writes for Swift Testing beside the XCTest one.
-# A case that passed only on a retry becomes a warning annotation.
 
-exec python3 - "$@" <<'PY'
-import json
-import os
-import subprocess
-import sys
-import urllib.parse
-import xml.etree.ElementTree as ET
-from pathlib import Path
-
-summary = open(os.environ.get("GITHUB_STEP_SUMMARY") or "/dev/stdout", "a", encoding="utf-8")
-status = 0
-
-
-def emit(text=""):
-    print(text, file=summary)
-
-
-def xcresulttool(bundle, *arguments):
-    result = subprocess.run(
-        ["xcrun", "xcresulttool", "get", *arguments, "--path", bundle, "--format", "json"],
-        capture_output=True, text=True)
-    return json.loads(result.stdout) if result.returncode == 0 else None
-
-
-def heading(name, cases, failed):
-    minutes = sum(case[2] for case in cases) / 60
-    emit(f"### {name}: {len(cases)} cases, {minutes:.1f} min"
-         + (f", {len(failed)} not passing" if failed else "") + "\n")
-    if failed:
-        for label in failed[:50]:
-            emit(f"- failed: `{label}`")
-        emit()
-
-
-def slowest(cases):
-    emit("<details><summary>Slowest 20 cases</summary>\n\n| case | suite | seconds |\n| --- | --- | ---: |")
-    for suite, name, seconds in sorted(cases, key=lambda case: -case[2])[:20]:
-        emit(f"| {name} | {suite} | {seconds:.1f} |")
-    emit("\n</details>\n")
-
-
-def build_errors(bundle, name):
-    build = xcresulttool(bundle, "build-results") or {}
-    errors = build.get("errors") or []
-    if not errors:
-        return
-    emit(f"### {name}: {len(errors)} build error{'' if len(errors) == 1 else 's'}\n")
-    for issue in errors[:50]:
-        url = urllib.parse.urlparse(issue.get("sourceURL") or "")
-        line = urllib.parse.parse_qs(url.fragment).get("StartingLineNumber", ["?"])[0]
-        location = f"`{url.path}:{line}` " if url.path else ""
-        emit(f"- {location}{issue.get('message', '')}")
-    emit()
-
-
-def test_cases(node, suite, found):
-    kind = node.get("nodeType")
-    if kind == "Test Case":
-        found.append((suite, node))
-        return
-    for child in node.get("children") or []:
-        test_cases(child, node.get("name", "") if kind == "Test Suite" else suite, found)
-
-
-def xcresult(bundle, name):
-    global status
-    build_errors(bundle, name)
-    content = xcresulttool(bundle, "content-availability") or {}
-    if not content.get("hasTestResults"):
-        return
-    tree = xcresulttool(bundle, "test-results", "tests")
-    if tree is None:
-        return
-    bundles = []
-    for plan in tree.get("testNodes") or []:
-        children = [child for child in plan.get("children") or [] if child.get("nodeType", "").endswith("test bundle")]
-        bundles.extend(children or [plan])
-    everything, failed, retried = [], [], []
-    for target in bundles:
-        found = []
-        test_cases(target, "", found)
-        executed = [(suite, case) for suite, case in found if case.get("result") != "Skipped"]
-        if not executed:
-            emit(f"### {name}: {target.get('name', '?')} executed no test\n")
-            print(f"::error::{name}: {target.get('name', '?')} executed no test")
-            status = 1
-        for suite, case in executed:
-            label = f"{target.get('name', '?')}/{suite + '/' if suite else ''}{case.get('name', '')}"
-            everything.append((suite, case.get("name", ""), case.get("durationInSeconds") or 0.0))
-            if case.get("result") not in ("Passed", "Expected Failure"):
-                failed.append(label)
-            elif any(child.get("nodeType") == "Repetition" and child.get("result") == "Failed"
-                     for child in case.get("children") or []):
-                retried.append(label)
-    if not everything:
-        return
-    heading(name, everything, failed)
-    if retried:
-        emit("Passed only on retry, a flake to fix:\n")
-        for label in retried:
-            emit(f"- `{label}`")
-            print(f"::warning title=Passed only on retry::{label}")
-        emit()
-    slowest(everything)
-
-
-def xunit(path, name):
-    global status
-    sources = [path, path.with_name(f"{path.stem}-swift-testing.xml")]
-    present = [source for source in sources if source.is_file()]
-    if not present:
-        return
-    everything, failed = [], []
-    for source in present:
-        for case in ET.parse(source).getroot().iter("testcase"):
-            if case.find("skipped") is not None:
-                continue
-            label = f"{case.get('classname', '')}/{case.get('name', '')}"
-            everything.append((case.get("classname", ""), case.get("name", ""), float(case.get("time") or 0)))
-            if case.find("failure") is not None or case.find("error") is not None:
-                failed.append(label)
-    if not everything:
-        emit(f"### {name}: no test executed\n")
-        print(f"::error::{name}: swift test executed no test")
-        status = 1
-        return
-    heading(name, everything, failed)
-    slowest(everything)
-
-
-for argument in sys.argv[1:]:
-    path = Path(argument)
-    if path.suffix == ".xml":
-        xunit(path, path.stem)
-    elif path.is_dir():
-        xcresult(argument, path.stem)
-sys.exit(status)
-PY
+exec python3 "$(dirname "$0")/../lib/xcresult-cases.py" summary "$@"
diff --git a/scripts/lib/test_xcresult_cases.py b/scripts/lib/test_xcresult_cases.py
new file mode 100644
index 0000000000..3e0148175f
--- /dev/null
+++ b/scripts/lib/test_xcresult_cases.py
@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""Tests for xcresult-cases.py. The fixtures keep the shape of xcresulttool 25115 output.
+
+Run: python3 -m unittest discover -s scripts/lib -p 'test_*.py'
+"""
+
+import importlib.util
+import io
+import tempfile
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
+SPEC = importlib.util.spec_from_file_location("xcresult_cases", Path(__file__).with_name("xcresult-cases.py"))
+parser = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(parser)
+
+
+def case(ident, result, seconds=0.5, children=None):
+    node = {"nodeType": "Test Case", "name": ident.rpartition("/")[2], "nodeIdentifier": ident,
+            "result": result, "durationInSeconds": seconds}
+    if children:
+        node["children"] = children
+    return node
+
+
+def suite(name, *children):
+    return {"nodeType": "Test Suite", "name": name, "children": list(children)}
+
+
+def repetition(result, message=None):
+    node = {"nodeType": "Repetition", "name": "First Run", "result": result}
+    if message:
+        node["children"] = [{"nodeType": "Failure Message", "name": message}]
+    return node
+
+
+MIXED = {"testNodes": [{"nodeType": "Test Plan", "name": "Unit", "children": [
+    {"nodeType": "Unit test bundle", "name": "ProbeTests", "children": [
+        case("freeFunction()", "Passed"),
+        suite("ClassicTests",
+              case("ClassicTests/testExpected()", "Expected Failure",
+                   children=[{"nodeType": "Expected Failure", "name": "known"}]),
+              case("ClassicTests/testFails()", "Failed", children=[
+                  repetition("Failed", "XCTAssertEqual failed: (\"4\") is not equal to (\"5\")"),
+                  repetition("Failed", "XCTAssertEqual failed: (\"4\") is not equal to (\"5\")")]),
+              case("ClassicTests/testFlaky()", "Passed", children=[
+                  repetition("Failed", "first try fails"), repetition("Passed")]),
+              case("ClassicTests/testSkipped()", "Skipped",
+                   children=[{"nodeType": "Skip Message", "name": "Test skipped - not here"}]),
+              case("ClassicTests/testOdd()", "unknown")),
+        suite("Outer",
+              suite("Inner",
+                    case("Outer/Inner/nestedPasses()", "Passed", seconds=12.0),
+                    case("Outer/Inner/nestedFails()", "Failed", children=[
+                        {"nodeType": "Failure Message", "name": "Expectation failed: double(3) == 7\ndouble(3) → 6"}])),
+              case("Outer/parameterized(value:)", "Passed", children=[
+                  {"nodeType": "Arguments", "name": "2", "result": "Passed",
+                   "children": [repetition("Failed", "flaky argument"), repetition("Passed")]}])),
+    ]},
+    {"nodeType": "UI test bundle", "name": "OnlySkippedTests", "children": [
+        suite("OnlySkipped", case("OnlySkipped/testSkipped()", "Skipped"))]},
+]}]}
+
+RUNNER_FAILED = {"testNodes": [{"nodeType": "Test Plan", "name": "TableProMobile", "children": [
+    {"nodeType": "Unit test bundle", "name": "TableProMobileTests", "children": [
+        suite("System Failures", {
+            "nodeType": "Test Case", "name": "TableProMobile encountered an error",
+            "nodeIdentifier": "TableProMobile encountered an error", "result": "Failed",
+            "children": [{"nodeType": "Failure Message",
+                          "name": "Failed to prepare device 'iPhone 18 Pro' for impending launch."}]})]}]}]}
+
+RUNNER_BUILD = {"errors": [{"issueType": "Uncategorized", "message":
+                            "TableProMobile encountered an error (Failed to prepare device 'iPhone 18 Pro')"}]}
+
+BROKEN_BUILD = {"errors": [
+    {"issueType": "Uncategorized", "message": "Testing cancelled because the build failed."},
+    {"issueType": "Swift Compiler Error", "message": "Cannot convert value of type 'String' to specified type 'Int'",
+     "sourceURL": "file:///Users/runner/work/TablePro/TablePro/Some%20Dir/Broken.swift"
+                  "#EndingColumnNumber=21&EndingLineNumber=3&StartingColumnNumber=21&StartingLineNumber=3"
+                  "&Timestamp=813945273.172478"},
+    {"issueType": "Uncategorized", "message": "Linker command failed with exit code 1"},
+]}
+
+XCTEST_XUNIT = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+<testsuite name="TestResults" errors="0" tests="3" failures="1" time="1.0">
+<testcase classname="ProbeTests.ClassicTests" name="testPasses" time="0.25">
+</testcase>
+<testcase classname="ProbeTests.ClassicTests" name="testFails" time="0.5">
+<failure message="failure"></failure>
+</testcase>
+<testcase classname="OtherTests.OnlySkippedTests" name="testSkipped" time="0.1">
+</testcase>
+</testsuite>
+</testsuites>
+"""
+
+SWIFT_TESTING_XUNIT = """<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+    <testsuite name="TestResults" errors="0" tests="3" failures="1" skipped="1" time="0.001">
+        <testcase classname="ProbeTests.Outer.Inner" name="nestedFails()" time="0.0007">
+            <failure message="Expectation failed: double(3) == 7 (error)"/>
+        </testcase>
+        <testcase classname="ProbeTests.Outer" name="disabled()">
+            <skipped>off</skipped>
+        </testcase>
+        <testcase classname="ProbeTests" name="freeFunction()" time="0.0002"/>
+    </testsuite>
+</testsuites>
+"""
+
+
+def by_label(cases):
+    return {case.label: case for case in cases}
+
+
+class BundleCaseTests(unittest.TestCase):
+    def setUp(self):
+        self.targets = parser.bundle_cases(MIXED)
+        self.cases = by_label(case for _, cases in self.targets for case in cases)
+
+    def test_labels_are_target_then_node_identifier(self):
+        self.assertIn("ProbeTests/freeFunction()", self.cases)
+        self.assertIn("ProbeTests/ClassicTests/testFails()", self.cases)
+        self.assertIn("ProbeTests/Outer/Inner/nestedPasses()", self.cases)
+        self.assertEqual(self.cases["ProbeTests/Outer/Inner/nestedPasses()"].suite, "ProbeTests/Outer/Inner")
+        self.assertEqual(self.cases["ProbeTests/freeFunction()"].suite, "ProbeTests")
+
+    def test_a_target_with_only_skipped_cases_is_kept(self):
+        self.assertEqual([name for name, _ in self.targets], ["ProbeTests", "OnlySkippedTests"])
+
+    def test_results(self):
+        self.assertEqual(self.cases["ProbeTests/ClassicTests/testExpected()"].result, "Expected Failure")
+        self.assertEqual(self.cases["ProbeTests/ClassicTests/testSkipped()"].result, "Skipped")
+        self.assertEqual(self.cases["ProbeTests/ClassicTests/testOdd()"].result, "Failed")
+
+    def test_a_pass_after_a_failed_repetition_is_a_retry(self):
+        self.assertTrue(self.cases["ProbeTests/ClassicTests/testFlaky()"].retried)
+        self.assertTrue(self.cases["ProbeTests/Outer/parameterized(value:)"].retried)
+        self.assertFalse(self.cases["ProbeTests/ClassicTests/testFails()"].retried)
+        self.assertFalse(self.cases["ProbeTests/freeFunction()"].retried)
+
+    def test_a_failure_keeps_its_first_message(self):
+        self.assertEqual(self.cases["ProbeTests/ClassicTests/testFails()"].message,
+                         "XCTAssertEqual failed: (\"4\") is not equal to (\"5\")")
+        self.assertEqual(self.cases["ProbeTests/ClassicTests/testFlaky()"].message, "")
+
+    def test_a_system_failure_is_a_runner_failure(self):
+        [(target, cases)] = parser.bundle_cases(RUNNER_FAILED)
+        self.assertEqual(target, "TableProMobileTests")
+        self.assertEqual([(case.result, case.label) for case in cases],
+                         [("System Failure", "TableProMobileTests/TableProMobile encountered an error")])
+        self.assertTrue(cases[0].message.startswith("Failed to prepare device"))
+
+    def test_a_plan_without_a_bundle_is_its_own_target(self):
+        tree = {"testNodes": [{"nodeType": "Test Plan", "name": "UI", "children": [
+            suite("System Failures", case("UI encountered an error", "Failed"))]}]}
+        [(target, cases)] = parser.bundle_cases(tree)
+        self.assertEqual((target, cases[0].result), ("UI", "System Failure"))
+
+    def test_a_failed_test_build_has_no_target(self):
+        self.assertEqual(parser.bundle_cases({"testNodes": []}), [])
+
+
+class BuildErrorTests(unittest.TestCase):
+    def test_lines_are_one_based_and_testing_cancelled_is_dropped(self):
+        self.assertEqual(list(parser.build_errors(BROKEN_BUILD)), [
+            ("/Users/runner/work/TablePro/TablePro/Some Dir/Broken.swift:4",
+             "Cannot convert value of type 'String' to specified type 'Int'"),
+            ("", "Linker command failed with exit code 1"),
+        ])
+
+    def test_no_build_results(self):
+        self.assertEqual(list(parser.build_errors(None)), [])
+
+
+class XunitTests(unittest.TestCase):
+    def setUp(self):
+        self.directory = tempfile.TemporaryDirectory()
+        self.root = Path(self.directory.name)
+
+    def tearDown(self):
+        self.directory.cleanup()
+
+    def write(self, name, text):
+        path = self.root / name
+        path.write_text(text, encoding="utf-8")
+        return path
+
+    def test_labels_match_swift_test_filters(self):
+        self.write("Core.xml", XCTEST_XUNIT)
+        self.write("Core-swift-testing.xml", SWIFT_TESTING_XUNIT)
+        cases = by_label(parser.xunit_cases(self.root / "Core.xml"))
+        self.assertEqual(sorted(cases), [
+            "OtherTests.OnlySkippedTests/testSkipped",
+            "ProbeTests.ClassicTests/testFails",
+            "ProbeTests.ClassicTests/testPasses",
+            "ProbeTests.Outer/Inner/nestedFails()",
+            "ProbeTests.Outer/disabled()",
+            "ProbeTests.freeFunction()",
+        ])
+        self.assertEqual(cases["ProbeTests.Outer/Inner/nestedFails()"].result, "Failed")
+        self.assertEqual(cases["ProbeTests.Outer/disabled()"].result, "Skipped")
+        self.assertEqual(cases["ProbeTests.freeFunction()"].target, "ProbeTests")
+        self.assertEqual(cases["ProbeTests.ClassicTests/testFails"].seconds, 0.5)
+
+    def test_the_swift_testing_file_alone_is_read(self):
+        self.write("Core-swift-testing.xml", SWIFT_TESTING_XUNIT)
+        self.assertEqual(len(parser.xunit_cases(self.root / "Core.xml")), 3)
+
+    def test_a_truncated_file_counts_nothing(self):
+        self.write("Core.xml", XCTEST_XUNIT[:120])
+        with redirect_stderr(io.StringIO()) as errors:
+            self.assertEqual(parser.xunit_cases(self.root / "Core.xml"), [])
+        self.assertIn("cannot read", errors.getvalue())
+
+
+class TallyTests(unittest.TestCase):
+    def test_counts_targets_retries_and_failures(self):
+        cases = [case for _, found in parser.bundle_cases(MIXED) for case in found]
+        filters = [("ClassicTests", parser.re.compile(r"^ProbeTests/ClassicTests(\(\))?(/|$)")),
+                   ("Nope", parser.re.compile(r"^ProbeTests/Nope(\(\))?(/|$)"))]
+        self.assertEqual(parser.tally(cases, filters), [
+            "tests: 8 executed, 4 passed, 3 failed, 2 skipped, 1 expected failures",
+            "targets: ProbeTests 8 (1 skipped), OnlySkippedTests 0 (1 skipped)",
+            "ran nothing: Nope",
+            "passed only on retry, a flake to fix:",
+            "  ProbeTests/ClassicTests/testFlaky()",
+            "  ProbeTests/Outer/parameterized(value:)",
+            "failures:",
+            "  ProbeTests/ClassicTests/testFails(): XCTAssertEqual failed: (\"4\") is not equal to (\"5\")",
+            "  ProbeTests/Outer/Inner/nestedFails(): Expectation failed: double(3) == 7",
+            "8 3 1 0",
+        ])
+
+    def test_a_runner_failure_is_not_an_executed_test(self):
+        cases = [case for _, found in parser.bundle_cases(RUNNER_FAILED) for case in found]
+        self.assertEqual(parser.tally(cases, []), [
+            "tests: 0 executed, 0 passed, 0 failed, 0 skipped, 1 runner failures",
+            "failures:",
+            "  TableProMobileTests/TableProMobile encountered an error: "
+            "Failed to prepare device 'iPhone 18 Pro' for impending launch.",
+            "0 0 0 1",
+        ])
+
+    def test_filters_file(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "run.filters"
+            path.write_text("Suite\t^T/Suite(\\(\\))?(/|$)\tT/Suite\n\nbroken\t[unclosed\n", encoding="utf-8")
+            filters = parser.read_filters(str(path))
+        self.assertEqual([label for label, _ in filters], ["Suite", "broken"])
+        self.assertTrue(filters[0][1].search("T/Suite/case()"))
+        self.assertFalse(filters[0][1].search("T/SuiteTwo/case()"))
+        self.assertTrue(filters[1][1].search("x[unclosed"))
+
+    def test_command_line(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / "Core-swift-testing.xml").write_text(SWIFT_TESTING_XUNIT, encoding="utf-8")
+            (root / "run.filters").write_text("Outer\t^ProbeTests\\.Outer(\\(\\))?(/|$)\n", encoding="utf-8")
+            with redirect_stdout(io.StringIO()) as out:
+                code = parser.main(["tally", "--filters", str(root / "run.filters"), str(root / "Core.xml")])
+        self.assertEqual(code, 0)
+        self.assertEqual(out.getvalue().splitlines()[-1], "2 1 0 0")
+
+
+class SummaryTests(unittest.TestCase):
+    def setUp(self):
+        self.directory = tempfile.TemporaryDirectory()
+        self.root = Path(self.directory.name)
+        self.bundles = {}
+        self.original = parser.xcresulttool
+        parser.xcresulttool = lambda bundle, *arguments: self.bundles.get(Path(bundle).stem, {}).get(arguments)
+
+    def tearDown(self):
+        parser.xcresulttool = self.original
+        self.directory.cleanup()
+
+    def bundle(self, name, tests=None, build=None):
+        (self.root / f"{name}.xcresult").mkdir()
+        self.bundles[name] = {("test-results", "tests"): tests, ("build-results",): build}
+        return str(self.root / f"{name}.xcresult")
+
+    def summarize(self, *arguments):
+        summary, annotations = io.StringIO(), io.StringIO()
+        code = parser.summarize(arguments, summary, annotations)
+        return code, summary.getvalue(), annotations.getvalue()
+
+    def test_build_errors_point_at_the_real_line(self):
+        code, summary, _ = self.summarize(self.bundle("Build", build=BROKEN_BUILD))
+        self.assertEqual(code, 0)
+        self.assertIn("### Build: 2 build errors", summary)
+        self.assertIn("`/Users/runner/work/TablePro/TablePro/Some Dir/Broken.swift:4` Cannot convert", summary)
+        self.assertNotIn("Testing cancelled", summary)
+
+    def test_a_runner_failure_is_listed_apart_and_ran_no_test(self):
+        code, summary, annotations = self.summarize(self.bundle("iOS", RUNNER_FAILED, RUNNER_BUILD))
+        self.assertEqual(code, 1)
+        self.assertIn("### iOS: TableProMobileTests executed no test", summary)
+        self.assertIn("### iOS: 1 runner failure outside any test", summary)
+        self.assertIn("- `TableProMobileTests/TableProMobile encountered an error`: Failed to prepare device", summary)
+        self.assertNotIn("build error", summary)
+        self.assertNotIn("not passing", summary)
+        self.assertIn("::error::iOS: TableProMobileTests executed no test", annotations)
+
+    def test_counts_failures_and_retries(self):
+        code, summary, annotations = self.summarize(self.bundle("Unit", MIXED))
+        self.assertEqual(code, 1)
+        self.assertIn("### Unit: OnlySkippedTests executed no test", summary)
+        self.assertIn("### Unit: 8 cases, 0.3 min, 3 not passing", summary)
+        self.assertIn("- failed: `ProbeTests/ClassicTests/testOdd()`", summary)
+        self.assertIn("| nestedPasses() | ProbeTests/Outer/Inner | 12.0 |", summary)
+        self.assertIn("::warning title=Passed only on retry::ProbeTests/ClassicTests/testFlaky()", annotations)
+
+    def test_xunit_and_missing_inputs(self):
+        (self.root / "Core.xml").write_text(XCTEST_XUNIT, encoding="utf-8")
+        (self.root / "Empty.xml").write_text("<testsuites/>", encoding="utf-8")
+        code, summary, annotations = self.summarize(
+            str(self.root / "Core.xml"), str(self.root / "Empty.xml"), str(self.root / "Oracle.xml"),
+            str(self.root / "UI.xcresult"))
+        self.assertEqual(code, 1)
+        self.assertIn("### Core: 3 cases, 0.0 min, 1 not passing", summary)
+        self.assertIn("| testFails | ProbeTests.ClassicTests | 0.5 |", summary)
+        self.assertIn("### Empty: swift test executed no test", summary)
+        self.assertNotIn("Oracle", summary)
+        self.assertEqual(annotations, "::error::Empty: swift test executed no test\n")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/lib/xcresult-cases.py b/scripts/lib/xcresult-cases.py
new file mode 100755
index 0000000000..8004a2f832
--- /dev/null
+++ b/scripts/lib/xcresult-cases.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Reads test cases and build errors from .xcresult bundles and swift test xunit files.
+
+Usage:
+  xcresult-cases.py tally [--filters <file>] <input>...
+      verify.sh's notes, then "<executed> <failed> <filters that ran nothing> <runner failures>"
+  xcresult-cases.py errors <bundle.xcresult>
+      build errors as "<file>:<line>: <message>"
+  xcresult-cases.py summary <input>...
+      the CI step summary; exits 1 when a bundle or a swift test run executed no test,
+      which xcodebuild and swift test both call success
+
+An input is a bundle.xcresult or swift test's X.xml, which also brings X-swift-testing.xml.
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.parse
+import xml.etree.ElementTree as ET
+from collections import Counter, namedtuple
+from pathlib import Path
+
+Case = namedtuple("Case", "target suite name label result retried seconds message")
+
+PASSED, FAILED, SKIPPED, EXPECTED = "Passed", "Failed", "Skipped", "Expected Failure"
+RUNNER = "System Failure"
+
+
+def xcresulttool(bundle, *arguments):
+    result = subprocess.run(
+        ["xcrun", "xcresulttool", "get", *arguments, "--path", str(bundle), "--compact"],
+        capture_output=True, text=True)
+    return json.loads(result.stdout) if result.returncode == 0 else None
+
+
+def descendants(node):
+    for child in node.get("children") or []:
+        yield child
+        yield from descendants(child)
+
+
+def walk(node, in_system_failures, found):
+    if node.get("nodeType") == "Test Case":
+        found.append((node, in_system_failures))
+        return
+    # A runner that crashed or never started is reported as a case in this suite; it is not a test.
+    in_system_failures = in_system_failures or (
+        node.get("nodeType") == "Test Suite" and node.get("name") == "System Failures")
+    for child in node.get("children") or []:
+        walk(child, in_system_failures, found)
+
+
+# A target that ran no case is kept, so the summary can name it.
+def bundle_cases(tree):
+    result = []
+    for plan in (tree or {}).get("testNodes") or []:
+        bundles = [node for node in descendants(plan) if (node.get("nodeType") or "").endswith("test bundle")]
+        for target in bundles or [plan]:
+            name = target.get("name", "?")
+            found = []
+            walk(target, False, found)
+            cases = []
+            for node, in_system_failures in found:
+                ident = node.get("nodeIdentifier") or node.get("name", "")
+                suite, _, case = ident.rpartition("/")
+                suite = f"{name}/{suite}" if suite else name
+                outcome = RUNNER if in_system_failures else node.get("result")
+                if outcome not in (PASSED, SKIPPED, EXPECTED, RUNNER):
+                    outcome = FAILED
+                message = next((child.get("name", "") for child in descendants(node)
+                                if child.get("nodeType") == "Failure Message"), "")
+                cases.append(Case(
+                    target=name, suite=suite, name=case, label=f"{suite}/{case}", result=outcome,
+                    retried=outcome == PASSED and any(
+                        child.get("nodeType") == "Repetition" and child.get("result") == FAILED
+                        for child in descendants(node)),
+                    seconds=node.get("durationInSeconds") or 0.0,
+                    message=message if outcome in (FAILED, RUNNER) else ""))
+            result.append((name, cases))
+    return result
+
+
+def xunit_sources(path):
+    return [source for source in (path, path.with_name(f"{path.stem}-swift-testing.xml")) if source.is_file()]
+
+
+def xunit_cases(path):
+    cases = []
+    for source in xunit_sources(path):
+        try:
+            root = ET.parse(source).getroot()
+        except ET.ParseError as error:
+            print(f"xcresult-cases.py: cannot read {source}: {error}", file=sys.stderr)
+            continue
+        for node in root.iter("testcase"):
+            # Swift Testing names a nested suite Target.Outer.Inner; swift test filters it as Target.Outer/Inner.
+            target, _, nested = node.get("classname", "").partition(".")
+            suite = f"{target}.{nested.replace('.', '/')}" if nested else target
+            name = node.get("name", "")
+            if node.find("skipped") is not None:
+                result = SKIPPED
+            elif node.find("failure") is not None or node.find("error") is not None:
+                result = FAILED
+            else:
+                result = PASSED
+            cases.append(Case(
+                target=target, suite=suite, name=name, label=f"{suite}/{name}" if nested else f"{target}.{name}",
+                result=result, retried=False, seconds=float(node.get("time") or 0), message=""))
+    return cases
+
+
+def cases_of(argument):
+    path = Path(argument)
+    if path.suffix == ".xml":
+        return xunit_cases(path)
+    tree = xcresulttool(path, "test-results", "tests") if path.is_dir() else None
+    return [case for _, cases in bundle_cases(tree) for case in cases]
+
+
+def build_errors(build):
+    for issue in (build or {}).get("errors") or []:
+        message = issue.get("message", "")
+        if message.startswith("Testing cancelled"):
+            continue
+        url = urllib.parse.urlparse(issue.get("sourceURL") or "")
+        path = urllib.parse.unquote(url.path)
+        # A document location counts lines from 0.
+        start = urllib.parse.parse_qs(url.fragment).get("StartingLineNumber", [""])[0]
+        if path and start.isdigit():
+            path = f"{path}:{int(start) + 1}"
+        yield path, message
+
+
+def read_filters(path):
+    filters = []
+    with open(path, encoding="utf-8") as handle:
+        for row in filter(None, handle.read().splitlines()):
+            fields = row.split("\t")
+            pattern = fields[1] if len(fields) > 1 else fields[0]
+            try:
+                filters.append((fields[0], re.compile(pattern)))
+            except re.error:
+                filters.append((fields[0], re.compile(re.escape(pattern))))
+    return filters
+
+
+def tally(cases, filters):
+    count = Counter(case.result for case in cases)
+    executed = [case for case in cases if case.result not in (SKIPPED, RUNNER)]
+    targets = {}
+    for case in cases:
+        if case.result != RUNNER:
+            targets.setdefault(case.target, Counter())[case.result == SKIPPED] += 1
+    lines = [f"tests: {len(executed)} executed, {count[PASSED]} passed, {count[FAILED]} failed, {count[SKIPPED]} skipped"
+             + (f", {count[EXPECTED]} expected failures" if count[EXPECTED] else "")
+             + (f", {count[RUNNER]} runner failures" if count[RUNNER] else "")]
+    if targets:
+        lines.append("targets: " + ", ".join(
+            f"{target} {ran[False]}" + (f" ({ran[True]} skipped)" if ran[True] else "")
+            for target, ran in targets.items()))
+    zero = [label for label, regex in filters if not any(regex.search(case.label) for case in executed)]
+    lines += [f"ran nothing: {label}" for label in zero]
+    retried = [case.label for case in executed if case.retried]
+    if retried:
+        lines += ["passed only on retry, a flake to fix:"] + [f"  {label}" for label in retried]
+    described = [case for case in cases if case.message][:10]
+    if described:
+        lines += ["failures:"] + [f"  {case.label}: {case.message.splitlines()[0]}" for case in described]
+    lines.append(f"{len(executed)} {count[FAILED]} {len(zero)} {count[RUNNER]}")
+    return lines
+
+
+def summarize(arguments, out, annotations):
+    status = 0
+
+    def emit(text=""):
+        print(text, file=out)
+
+    def no_test(text):
+        nonlocal status
+        emit(f"### {text}\n")
+        print(f"::error::{text}", file=annotations)
+        status = 1
+
+    def listing(heading, labels):
+        if not labels:
+            return
+        if heading:
+            emit(heading + "\n")
+        emit("\n".join(labels[:50]) + "\n")
+
+    def report(name, cases):
+        failed = [case for case in cases if case.result == FAILED]
+        minutes = sum(case.seconds for case in cases) / 60
+        emit(f"### {name}: {len(cases)} cases, {minutes:.1f} min"
+             + (f", {len(failed)} not passing" if failed else "") + "\n")
+        listing(None, [f"- failed: `{case.label}`" for case in failed])
+        retried = [case.label for case in cases if case.retried]
+        listing("Passed only on retry, a flake to fix:", [f"- `{label}`" for label in retried])
+        for label in retried:
+            print(f"::warning title=Passed only on retry::{label}", file=annotations)
+        emit("<details><summary>Slowest 20 cases</summary>\n\n| case | suite | seconds |\n| --- | --- | ---: |")
+        for case in sorted(cases, key=lambda case: -case.seconds)[:20]:
+            emit(f"| {case.name} | {case.suite} | {case.seconds:.1f} |")
+        emit("\n</details>\n")
+
+    for argument in arguments:
+        path = Path(argument)
+        name = path.stem
+        if path.suffix == ".xml":
+            if not xunit_sources(path):
+                continue
+            executed = [case for case in xunit_cases(path) if case.result != SKIPPED]
+            if executed:
+                report(name, executed)
+            else:
+                no_test(f"{name}: swift test executed no test")
+            continue
+        if not path.is_dir():
+            continue
+        targets = bundle_cases(xcresulttool(path, "test-results", "tests"))
+        runner = [case for _, cases in targets for case in cases if case.result == RUNNER]
+        # The action log repeats each runner failure as an error, and it is no build error.
+        errors = [(where, message) for where, message in build_errors(xcresulttool(path, "build-results"))
+                  if not any(message.startswith(case.name) for case in runner)]
+        plural = "" if len(errors) == 1 else "s"
+        listing(f"### {name}: {len(errors)} build error{plural}",
+                [f"- `{where}` {message}" if where else f"- {message}" for where, message in errors])
+        executed = []
+        for target, cases in targets:
+            ran = [case for case in cases if case.result not in (SKIPPED, RUNNER)]
+            if not ran:
+                no_test(f"{name}: {target} executed no test")
+            executed += ran
+        plural = "" if len(runner) == 1 else "s"
+        listing(f"### {name}: {len(runner)} runner failure{plural} outside any test",
+                [f"- `{case.label}`" + (f": {case.message.splitlines()[0]}" if case.message else "")
+                 for case in runner])
+        if executed:
+            report(name, executed)
+    return status
+
+
+def main(arguments):
+    command, rest = (arguments[0], arguments[1:]) if arguments else ("", [])
+    if command == "tally":
+        filters = []
+        if rest[:1] == ["--filters"] and len(rest) > 1:
+            filters, rest = read_filters(rest[1]), rest[2:]
+        print("\n".join(tally([case for argument in rest for case in cases_of(argument)], filters)))
+        return 0
+    if command == "errors" and len(rest) == 1:
+        for where, message in build_errors(xcresulttool(Path(rest[0]), "build-results")):
+            print(f"{Path(where).name}: {message}" if where else message)
+        return 0
+    if command == "summary":
+        destination = os.environ.get("GITHUB_STEP_SUMMARY")
+        if not destination:
+            return summarize(rest, sys.stdout, sys.stdout)
+        with open(destination, "a", encoding="utf-8") as out:
+            return summarize(rest, out, sys.stdout)
+    print(__doc__.strip(), file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))