testing: a case sees only the payloads it states, and one CI criterion reads narration from stderr

Two failures from the other platforms, with one cause each.

The kit left the real build's `MCPP_XPKG_*` in the environment. These cases run
inside a build program, which the engine gives one `_DIR`, `_PROGRAM` and
`_SOURCE` per payload its package declares -- including `pending`, for a payload
declared `provision = "on-request"` that nothing has asked for. Eight vcpkg cases
therefore asked for `xim:vcpkg` and planned nothing wherever the payload was not
installed, and passed wherever it was: 19 of 27 on macOS arm64 and on Windows, 27
of 27 here. The keys are derived from package names, so they are enumerated
rather than listed. Measured both ways on the same binary with the inherited
value present: 19 of 27 before, 27 of 27 after.

The spirv fixture's step asserted on a status line while capturing stdout alone.
mcpp writes narration to standard error from 2026.10.1.1, so the log was empty
and the step reported that the rule had not run while it had.

Author: speak-agent

.github/workflows/ci.yml

@@ -746,7 +746,11 @@ jobs:
             grep -v '^[[:space:]]*#' mcpp.toml | grep -n 'host-module'
             exit 1
           fi
-          "$MCPP" build | tee build.log
+          # `2>&1`, BECAUSE THE LINE THIS ASSERTS ON IS NARRATION. mcpp writes
+          # every status line to standard error from 2026.10.1.1 (the output
+          # streams design), so a step that captures stdout alone reads an empty
+          # log and reports that the rule did not run while it did.
+          "$MCPP" build 2>&1 | tee build.log
           grep -q 'Rules mcpp.rules.spirv' build.log \
             || { echo "FAIL: the build did not report which rule it ran"; exit 1; }
           "$MCPP" run | tee run.log

src/testing.cppm

@@ -39,6 +39,9 @@
 
 module;
 #include <stdlib.h>
+#if !defined(_WIN32)
+#include <unistd.h>     // environ -- the kit clears the real build's MCPP_XPKG_*
+#endif
 
 export module mcpp.plugins.testing;
 
@@ -71,10 +74,39 @@ inline constexpr std::string_view kKeys[] = {
     "MCPP_TOOL_ENV", "MCPP_TOOLSET_IDENTITY", "MCPP_MSVC_INSTANCE_DIR", "MCPP_NINJA",
     "MCPP_CXX_RUNTIME", "MCPP_MSVC_CRT_LINKAGE",
     // Sources (0.19.0, mcpp#755): which phase is running. The per-payload keys
-    // are stated by `context::xpkg*`, which names them itself.
+    // are stated by `context::xpkg*`, which names them itself, and the ones the
+    // real build set are cleared by `inherited_payload_keys`.
     "MCPP_PHASE",
 };
 
+// EVERY `MCPP_XPKG_*` THE REAL BUILD SET, so that a case sees only the payloads
+// it states. These cases run inside a build program, and the engine gives that
+// program one `_DIR`, `_PROGRAM` and `_SOURCE` for each payload its package
+// declares -- `pending` among them, for a payload declared
+// `provision = "on-request"` and not installed. Inherited, that made the eight
+// vcpkg cases ask for `xim:vcpkg` and plan nothing on a host where it was not
+// installed, while passing on one where it was; the symptom was a plan with the
+// prefix mapping but no install action (measured on macOS arm64, 0.19.0).
+//
+// Enumerated rather than listed: the keys are derived from package names, so no
+// fixed list can cover the next payload a member reads.
+inline std::vector<std::string> inherited_payload_keys() {
+#if defined(_WIN32)
+    char** env = _environ;
+#else
+    char** env = environ;
+#endif
+    std::vector<std::string> out;
+    for (char** e = env; e && *e; ++e) {
+        std::string_view entry(*e);
+        const auto eq = entry.find('=');
+        if (eq == std::string_view::npos) continue;
+        const auto name = entry.substr(0, eq);
+        if (name.starts_with("MCPP_XPKG_")) out.emplace_back(name);
+    }
+    return out;
+}
+
 inline std::string read_file(const std::filesystem::path& p) {
     std::ifstream in(p, std::ios::binary);
     return {std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>()};
@@ -293,6 +325,8 @@ inline int run(int argc, char** argv, std::span<const test_case> cases) {
     // The union of the keys any case states, beside the kit's own list.
     std::vector<std::string> keys;
     for (auto k : detail::kKeys) keys.emplace_back(k);
+    for (auto& k : detail::inherited_payload_keys())
+        if (std::ranges::find(keys, k) == keys.end()) keys.push_back(std::move(k));
     for (auto const& c : cases)
         for (auto const& kv : c.ctx.values)
             if (std::ranges::find(keys, kv.first) == keys.end()) keys.push_back(kv.first);