bench: waive the last two cells, each with the evidence that bounds it

bench went 7/10 -> 8/10 last run (the xmake+libc++ waiver took effect). These
are the remaining two, and both are foreign tools, not mcpp.

linux/gcc/mcpp — cmake CONFIGURES and then fails at GENERATE with
`"__CMAKE::CXX23" ... not provided by the toolchain. Reason: Only `libstdc++`
is supported`. Every externally checkable fact was checked, one per cycle, and
every one AGREES with a developer box where this arm configures, generates and
builds:

    same cmake        the very same xim-x-cmake/4.0.2 xlings payload, not
                      merely the same version number
    same gcc          xim-x-gcc/16.1.0
    manifest          libstdc++.modules.json present on the runner
    its sources       std.cc and std.compat.cc present on the runner
    flags             the runner's exact `-B<glibc>/lib -L<glibc>/lib` shape
                      reproduced here with a fake MCPP_HOME and it works

What is left is inside CMake's own detection. Baseline moved to the released
mcpp for this cell, exactly as the xlings cells already do — normalising against
an engine that produced no binary prints bare seconds under a heading that says
"relative to". xmake and both mcpp arms stay measured.

windows/clang/fixture — two upstream gaps. xmake exits -1 (0xFFFFFFFF) from the
seed build; that USED to read as `could not start the process`, which was this
harness's own defect and is fixed, so it is now honestly an exit code and it is
xmake's. bazel fails in `msvc_deps_scanner_wrapper_x64.bat ... The syntax of the
command is incorrect` on modules-impl — rules_cc's MSVC dependency scanner. The
OTHER bazel failure on this cell was ours and is fixed (`--force_pic`), which
recovered the headers and modules variants: 36 ok -> 42 ok.

Also: the CMakeConfigureLog extraction now GREPS for the std-module entries
before tailing. The first version tailed 120 lines and got the ABI probe,
because that is what CMake writes last — the entries it was added for sit
earlier and were cut off. Same lesson as the build logs, made twice.

Author: speak-agent

bench/matrix.json

@@ -117,7 +117,9 @@
       "engines": "mcpp,cmake,xmake,bazel",
       "variants": "headers,modules,modules-impl",
       "scenarios": "cold,noop,touch-hub,touch-leaf,edit-body,edit-comment",
-      "preset": "standard"
+      "preset": "standard",
+      "allow_failed": "xmake,bazel",
+      "note": "KNOWN GAP, two of them, in two foreign tools on Windows. xmake: exits -1 (0xFFFFFFFF) from the seed build. It USED to be reported as `could not start the process`, which was the harness's own bug — Windows crash/abort statuses are large DWORDs that become negative ints, and `started()` inferred launch failure from the sign. That is fixed, so this is now honestly an exit code, and it is xmake's. bazel: `msvc_deps_scanner_wrapper_x64.bat failed ... The syntax of the command is incorrect` on the modules-impl variant — rules_cc's MSVC dependency scanner, not something this suite passes. A separate bazel failure on this cell WAS ours and is fixed: `--force_pic` is fatal on Windows (`supports_pic` is not enabled there), and dropping it recovered the headers and modules variants. cmake and mcpp stay measured here."
     },
     {
       "os": "windows",
@@ -138,8 +140,10 @@
       "scenarios": "cold,noop,touch-hub,edit-body,edit-comment",
       "hub": "src/platform/platform.cppm",
       "body": "src/version_req.cppm",
-      "note": "touch-leaf omitted: a real tree has no unit nobody imports that is also stable enough to name",
-      "buildfiles": "mcpp"
+      "note": "KNOWN GAP: cmake cannot GENERATE this project on the runner. It configures (the compiler probe passes) and then fails with `CMake Error: the \"CXX_MODULE_STD\" property ... requires that the \"__CMAKE::CXX23\" target exist, but it was not provided by the toolchain. Reason: Only `libstdc++` is supported`. Everything checkable from outside has been checked and every one of them AGREES with a developer box where the same arm configures, generates and builds: same cmake (the very same `xim-x-cmake/4.0.2` xlings payload, not merely the same version), same `xim-x-gcc/16.1.0`, `libstdc++.modules.json` present on the runner, both sources it names (`std.cc`, `std.compat.cc`) present on the runner, and the runner's exact flag shape (`-B<glibc>/lib -L<glibc>/lib`, the branch this machine does not normally take) reproduced locally via a fake MCPP_HOME with no subos — it works there. What is left is inside CMake's own detection. The arm's CMakeConfigureLog is now attached to the cell log on failure so the next look starts from CMake's own record rather than another hypothesis. BASELINE MOVED to the released mcpp for this cell, exactly as the xlings cells do: normalising against an engine that never produced a binary prints bare seconds under a heading that says `relative to`. xmake and both mcpp arms stay measured here. The published cmake numbers in bench/README were taken on a machine where this arm works.",
+      "buildfiles": "mcpp",
+      "allow_failed": "cmake",
+      "baseline": "2026.8.11.3"
     },
     {
       "os": "linux",

bench/src/engines/cmake.cppm

@@ -91,12 +91,25 @@ public:
         // nothing and a red one carries its own evidence.
         if (!r.ok()) {
             const auto detail = job.build_dir / "CMakeFiles" / "CMakeConfigureLog.yaml";
-            if (const auto tail = platform::tail_of(detail, 120); !tail.empty()) {
-                std::ofstream log(job.log_path, std::ios::app);
-                if (log) {
-                    log << "\n--- CMakeConfigureLog.yaml (last 120 lines) ---\n"
+            // GREP, then tail. The first version took the last 120 lines and got
+            // the ABI/linker-id probe, because that is what CMake happens to
+            // write last — the std-module detection this was added for sits
+            // EARLIER in the file and was cut off. Same lesson as the build
+            // logs: a tail answers "what happened at the end", not "why did it
+            // fail".
+            std::ofstream log(job.log_path, std::ios::app);
+            if (log) {
+                if (const auto hits = platform::log_grep(
+                        detail,
+                        {"CXX_MODULE_STD", "IMPORT_STD", "import std", "CXX23",
+                         "modules.json", "libstdc++", "std module"},
+                        40);
+                    !hits.empty())
+                    log << "\n--- CMakeConfigureLog.yaml (std-module entries) ---\n"
+                        << hits;
+                if (const auto tail = platform::tail_of(detail, 60); !tail.empty())
+                    log << "\n--- CMakeConfigureLog.yaml (last 60 lines) ---\n"
                         << tail;
-                }
             }
         }
         return r;