fix(e2e): drop requires-hard — a token cannot know which runner it is on

Shipped it, used it once, and CI proved it wrong within the hour:

    FAIL: 130_freestanding_riscv_build_and_run.sh
          (REQUIRED capability missing: llvm)   ← the macOS e2e suite

`llvm` and `qemu-riscv` are absent on the macOS and Windows runners BY DESIGN,
so a token whose absence fails makes those jobs structurally red — a worse
outcome than the silent skip it was meant to prevent. The same word has to mean
both "this platform legitimately lacks it" and "this runner is misconfigured",
and nothing in the token can tell them apart.

The guard that works has to know WHICH runner it is talking about, so it lives
in the job. ci-linux-e2e.yml's `baremetal` job installs qemu and the sysroot
(into the home MCPP uses, or 131 skips), runs the two scripts DIRECTLY — they
are standalone, run_all.sh takes no filter and would run all 250 tests for two
— and then asserts each script's PASS line appeared. Both scripts can exit 0
without running, so the exit code alone cannot answer the question.

run_all.sh keeps the qemu-riscv capability probe and gains a comment saying why
the hard form is not there, so the next person does not re-derive it.

Author: speak-agent

.github/workflows/ci-linux-e2e.yml

@@ -158,16 +158,28 @@ jobs:
           # llvm is the toolchain a freestanding target pins; install it
           # explicitly rather than relying on whatever the sandbox cache holds.
           "$MCPP" toolchain install llvm 22.1.8
-          bash tests/e2e/run_all.sh 13 2>&1 | tee e2e.log
-          # The assertion this job exists for: the tests RAN. `run_all.sh`
-          # exits 0 on a skip, so its exit code cannot answer this.
-          grep -q 'PASS: freestanding riscv64 build + run' e2e.log || {
-            echo "130 (engine chain) did not run — see above"; exit 1; }
-          grep -q 'PASS: BSP supplies the sysroot' e2e.log || {
-            echo "131 (ecosystem chain) did not run — see above"; exit 1; }
-          if grep -qE '^SKIP: 13[01]' e2e.log; then
-            echo "a bare-metal e2e SKIPPED on the runner that must run it"; exit 1
-          fi
+          # Run the two scripts DIRECTLY rather than through run_all.sh.
+          # They are standalone (they take $MCPP and nothing else), run_all.sh
+          # accepts no filter — it would run the whole 250-test suite here for
+          # two tests — and, more to the point, run_all.sh exits 0 on a skip.
+          # Invoked directly, a skip is visible: the script either prints its
+          # PASS line or it does not.
+          for t in tests/e2e/130_freestanding_riscv_build_and_run.sh \
+                   tests/e2e/131_freestanding_bsp_supplies_everything.sh; do
+            echo "=== $t ==="
+            bash "$t" 2>&1 | tee "$(basename "$t").log"
+            rc=${PIPESTATUS[0]}
+            [ "$rc" = "0" ] || { echo "$t failed (exit $rc)"; exit 1; }
+          done
+          # The assertion this job exists for: both tests RAN. Each has an
+          # early `exit 0` for a missing capability, so a zero exit code alone
+          # does not distinguish "passed" from "skipped".
+          grep -q 'PASS: freestanding riscv64 build + run' \
+            130_freestanding_riscv_build_and_run.sh.log || {
+            echo "130 (engine chain) skipped on the runner that must run it"; exit 1; }
+          grep -q 'PASS: BSP supplies the sysroot' \
+            131_freestanding_bsp_supplies_everything.sh.log || {
+            echo "131 (ecosystem chain) skipped on the runner that must run it"; exit 1; }
 
   # ──────────────────────────────────────────────────────────────────
   # Hermetic (no host toolchain): the ONLY environment class that

tests/e2e/130_freestanding_riscv_build_and_run.sh

@@ -1,16 +1,28 @@
 #!/usr/bin/env bash
-# requires-hard: llvm qemu-riscv unix-shell
+# requires: llvm qemu-riscv unix-shell
 # Bare metal, end to end: `mcpp build --target riscv64-none-elf` produces a
 # RISC-V firmware image from a C++20 MODULE interface unit plus assembly, and
 # `mcpp run --target-triple` boots it in qemu.
 #
-# ⚠️ `requires-hard`, not `requires`. Every capability here is one a runner
-# that runs this file is supposed to have: llvm is mcpp's own payload and
-# qemu-riscv is an xim package. Declared the soft way, a runner that lost
-# either would report SKIP — indistinguishable from "inapplicable on this
-# platform" — and the one test that proves the bare-metal chain works would
-# stop running while the job stayed green. That has happened twice in this
-# repository already.
+# ⚠️ SOFT `requires:`, and the guard lives elsewhere on purpose.
+#
+# `requires-hard:` (missing capability FAILS instead of skipping) exists and is
+# the right tool for "this runner is misconfigured" — but it cannot express
+# THIS test's condition. Neither `llvm` nor `qemu-riscv` is present on the
+# macOS and Windows e2e runners, so a hard token here makes those jobs
+# structurally red forever — measured, not predicted: this file shipped with
+# `requires-hard` for one round and the macOS suite reported
+#
+#     FAIL: 130_freestanding_riscv_build_and_run.sh
+#           (REQUIRED capability missing: llvm)
+#
+# which is a worse failure than the one it was meant to prevent.
+#
+# The thing that must not happen — this test silently skipping on the runner
+# that is supposed to run it, leaving the bare-metal chain unexercised while
+# the job stays green — is guarded in ci-linux-e2e.yml, which installs the
+# capabilities and then asserts this test's PASS line actually appeared. A
+# guard belongs where it can be exact about which runner it is talking about.
 #
 # What each assertion is FOR (none of them is decoration):
 #

tests/e2e/run_all.sh

@@ -186,9 +186,8 @@ bad_tokens=0
 for tf in "$HERE"/[0-9]*.sh; do
     base="$(basename "$tf")"
     req="$(sed -n '2p' "$tf")"
-    [[ "$req" =~ ^#\ requires(-hard)?: ]] || continue
+    [[ "$req" =~ ^#\ requires: ]] || continue
     toks="${req#\# requires:}"
-    toks="${toks#\# requires-hard:}"
     for tok in $toks; do
         if [[ " ${KNOWN_CAPS[*]} " != *" $tok "* ]]; then
             echo "ERROR: $base declares unknown capability '$tok' — it would be"
@@ -206,18 +205,22 @@ done
 # Returns 0 (true) if the test should be skipped, prints reason.
 # Returns 1 (false) if all requirements are met.
 
-# `# requires-hard:` — a missing capability FAILS instead of skipping.
+# ⚠️ THERE IS DELIBERATELY NO "requires-hard" FORM.
 #
-# The ordinary form is right for a test that is genuinely inapplicable here
-# (msvc on Linux). It is wrong for a test whose capability the runner is
-# SUPPOSED to have: the skip line is indistinguishable from a legitimate one,
-# so a job that silently stopped exercising the thing it exists to exercise
-# stays green forever. This repository has hit that twice (65_* never ran at
-# all; ten pack e2e skipped on two platforms). A test that declares its needs
-# with the hard form says "if this is missing, the runner is misconfigured".
-requires_is_hard() {
-    [[ "$(sed -n '2p' "$1")" =~ ^#\ requires-hard: ]]
-}
+# The obvious answer to "a test silently skipped on the runner that was
+# supposed to run it" is a token whose absence FAILS. It was implemented here,
+# used once, and measured wrong: a token cannot tell "this runner is
+# misconfigured" from "this platform legitimately lacks the capability",
+# because the same word means both. `llvm` and `qemu-riscv` are absent on the
+# macOS runner by design, so the one test that declared them the hard way made
+# the macOS suite fail — a worse outcome than the silent skip it was meant to
+# prevent, and one CI reported within the hour.
+#
+# The guard that works has to know WHICH runner it is talking about, so it
+# lives in the job: ci-linux-e2e.yml's `baremetal` job installs the
+# capabilities and then asserts the tests' PASS lines actually appeared.
+# `run_all.sh` exits 0 on a skip, so its exit code cannot answer that question
+# and no token can either.
 
 check_requires() {
     local test_file="$1"
@@ -226,10 +229,9 @@ check_requires() {
     req_line="$(sed -n '2p' "$test_file")"
 
     # If there's no requires comment at all, run the test
-    [[ "$req_line" =~ ^#\ requires(-hard)?: ]] || return 1
+    [[ "$req_line" =~ ^#\ requires: ]] || return 1
 
     local caps_needed="${req_line#\# requires:}"
-    caps_needed="${caps_needed#\# requires-hard:}"
     caps_needed="${caps_needed# }"   # strip leading space
 
     # Empty requirements → runs everywhere
@@ -331,14 +333,6 @@ for test in "$HERE"/[0-9]*.sh; do
     echo
     missing_cap="$(check_requires "$test")"
     if [[ -n "$missing_cap" ]]; then
-        if requires_is_hard "$test"; then
-            echo "FAIL: $name (REQUIRED capability missing: $missing_cap)"
-            echo "      declared with '# requires-hard:', so this runner is"
-            echo "      misconfigured rather than merely inapplicable."
-            FAILED_TESTS+=("$name (REQUIRED capability missing: $missing_cap)")
-            ((FAIL++))
-            continue
-        fi
         echo "SKIP: $name (missing capability: $missing_cap)"
         ((SKIP++))
         continue