From 1fec0c503d9bf3176ed7e645311ea6e5ccec0537 Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 13:32:40 -0400
Subject: [PATCH 1/9] Plan the extraction of the negative compile test macro
 into a reusable infra module

The add_fail_test macro in tests/beman/expected/CMakeLists.txt is used 59
times here and once, in weaker form, in beman.optional. Lay out how it
becomes beman-xfail-compile.cmake in bemanproject/infra, consumed the same
way as beman-install-library and BuildTelemetry: a project-local copy and
call-site conversion first, a driver script that tells a successful
compile from a wrongly-failed one, the EXPECT comment made authoritative
after reconciling the 24 files where it has drifted from the CMake regex,
then the infra PR and the pin bump.
---
 docs/plan/extract-xfail-compile.md | 373 +++++++++++++++++++++++++++++
 1 file changed, 373 insertions(+)
 create mode 100644 docs/plan/extract-xfail-compile.md

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
new file mode 100644
index 0000000..39cd417
--- /dev/null
+++ b/docs/plan/extract-xfail-compile.md
@@ -0,0 +1,373 @@
+# Plan: extract-xfail-compile
+
+**Branch:** `extract-xfail-compile` (from `upstream/main` at `cb743bf`)
+**Read first:** `docs/plan/tests-overview.md` §3 and §6 — the negative
+compile test pattern and the coverage rule that makes it load-bearing.
+
+---
+
+## Goal
+
+Turn the `add_fail_test()` macro in `tests/beman/expected/CMakeLists.txt`
+into a reusable CMake module that lives in `bemanproject/infra` next to
+`beman-install-library.cmake` and `BuildTelemetryConfig.cmake`, is consumed
+the same way (`include(infra/cmake/<module>.cmake)` then one function call per
+test), and is documented in the infra README in the same shape as those two.
+
+`beman.expected` becomes the first consumer, with no change to which tests
+pass, and `beman.optional` is the obvious second one.
+
+## What exists today
+
+### In `beman.expected`
+
+`tests/beman/expected/CMakeLists.txt` defines a three-argument macro and
+calls it 59 times:
+
+```cmake
+macro(add_fail_test name source reason)
+    add_library(beman.expected.tests.${name} OBJECT)
+    target_sources(beman.expected.tests.${name} PRIVATE ${source})
+    target_link_libraries(beman.expected.tests.${name} PRIVATE beman::expected)
+    set_target_properties(beman.expected.tests.${name}
+        PROPERTIES EXCLUDE_FROM_ALL true EXCLUDE_FROM_DEFAULT_BUILD true)
+    add_test(NAME ${name}
+        COMMAND ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}"
+                --target beman.expected.tests.${name} --config $<CONFIGURATION>)
+    set_tests_properties(${name} PROPERTIES PASS_REGULAR_EXPRESSION "${reason}")
+endmacro()
+```
+
+The moving parts, each of which the module has to keep:
+
+- **An OBJECT library per test**, excluded from `all`, so the ill-formed
+  translation unit is never built by an ordinary build and is never linked.
+  Linking to `beman::expected` is what gives it the real include paths,
+  compile features, and (under `BEMAN_EXPECTED_USE_MODULES`) the module BMI.
+- **The test is a nested build.** ctest runs `cmake --build --target` on that
+  one object library, so the compiler invocation is exactly the one the
+  library's own tests get: same toolchain file, same flags, same launcher.
+- **Pass means "the output matched the regex".** A compile that succeeds
+  produces no diagnostic and fails the test. A compile that fails for an
+  unrelated reason also fails the test, because the regex names the intended
+  `static_assert` text, deleted-function wording, or "no matching function".
+  The regexes carry alternations for gcc, clang, and MSVC phrasing.
+
+Every `*_fail.test.cpp` is also supposed to carry a header comment
+(`// NEGATIVE: ...` and `// EXPECT: "<regex>"`) repeating the regex. An
+audit on this branch's base shows that convention has drifted:
+
+| EXPECT comment vs CMake regex | Files |
+|---|---|
+| identical | 35 |
+| different (CMake regex is a superset, usually adding MSVC/clang wording) | 15 |
+| no EXPECT comment at all | 9 |
+
+So the CMake argument is the authority today and the comment is
+documentation that has fallen behind. See
+[expect-authority](#expect-authority).
+
+### In `beman.optional`
+
+One negative test (`constructor_fails`) built the same way, but checked with
+`WILL_FAIL true` and the regex check commented out. That is the weaker form:
+it passes when the file fails to compile for *any* reason, including a typo.
+It is the same mechanism with the diagnostic check turned off, which is
+exactly what a shared module makes cheap to turn back on.
+
+### In `infra`
+
+`infra/cmake/` holds two reusable modules and the shape to copy:
+
+- `beman-install-library.cmake`: `include_guard(GLOBAL)`, a long header
+  comment giving Usage / Arguments / Brief / Cache variables / Caveats, a
+  `cmake_parse_arguments` keyword interface, verbose `message()`s prefixed
+  with the function name, and a sibling data file (`Config.cmake.in`) found
+  via `CMAKE_CURRENT_FUNCTION_LIST_DIR`.
+- `BuildTelemetryConfig.cmake` plus `telemetry.sh`: a module that ships a
+  helper script next to itself, callable via `include()` or via
+  `find_package()` with `CMAKE_PREFIX_PATH=infra/cmake`.
+- Both documented in `infra/README.md` under "CMake Modules".
+- Formatting is gersemi, enforced by infra's pre-commit.
+
+Nothing in infra does compile-failure tests, and infra has no tests of its
+own modules; consumers are the test.
+
+`infra/` in this repo is subtree-vendored by the `beman-submodule` CLI
+(pinned in `infra/.beman_submodule` to `749c558`), so edits made under
+`infra/` here are overwritten by the next `beman-submodule update`. The
+module has to go upstream through a fork of `bemanproject/infra`
+(`~/src/beman-infra/main`, `origin` = `steve-downey/infra`; it needs an
+`upstream` remote added for the PR).
+
+## Proposed interface
+
+```cmake
+include(infra/cmake/beman-xfail-compile.cmake)
+
+beman_add_xfail_compile_test(unexpected_array_fail
+    SOURCE unexpected_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
+)
+```
+
+```
+beman_add_xfail_compile_test(<name>
+    SOURCE <file>
+    [EXPECT <regex>]                 # omitted: read `// EXPECT: "..."` from SOURCE
+    [LINK_LIBRARIES <target>...]
+    [COMPILE_DEFINITIONS <def>...]
+    [TARGET_PREFIX <prefix>]         # default "${PROJECT_NAME}.tests."
+    [LABELS <label>...]              # always also gets "xfail-compile"
+)
+```
+
+- `<name>` is the ctest name, unchanged from today so `ctest -R` habits and
+  CI logs keep working.
+- The object-library target is `<TARGET_PREFIX><name>`; the default
+  reproduces `beman.expected.tests.<name>` for this repo with no argument.
+- Every test gets the label `xfail-compile`, so `ctest -L xfail-compile`
+  runs just the negative suite and `-LE` skips it.
+- Every test gets `RESOURCE_LOCK beman-xfail-compile-build-tree`. See
+  [concurrent-nested-builds](#concurrent-nested-builds).
+- A tiny `beman-xfail-compile-driver.cmake` next to the module is what
+  ctest actually runs. See [failure-detection](#failure-detection).
+
+## Stages
+
+Ordinals are reading order only. Identity is the slug.
+
+### Stage 1 — [module-in-project](#module-in-project)
+
+Write the module as `cmake/beman-xfail-compile.cmake` in this repo, with
+the exact content intended for infra (SPDX line, `include_guard(GLOBAL)`,
+header doc block, gersemi-clean). Convert all 59 `add_fail_test` calls to
+`beman_add_xfail_compile_test` with explicit `EXPECT`, keeping each regex
+byte-identical. Delete the macro.
+
+Acceptance: `ctest -N` lists the same 59 test names; the full suite passes
+on gcc and on clang with libstdc++ (`make TOOLCHAIN=gcc-16 test`,
+`make TOOLCHAIN=clang-23-libstdc++ test`); `make lint` is clean; a
+deliberately broken regex on one test makes that one test fail.
+
+This stage is mergeable to `main` on its own and does not wait on infra.
+
+### Stage 2 — [driver-script](#driver-script)
+
+Add `cmake/beman-xfail-compile-driver.cmake` and have the module's
+`add_test` run it with `-P`, passing build dir, target, `$<CONFIG>`, and
+the regex. The driver runs the nested build with `execute_process`, then:
+
+- exit code 0 → fail with "compiled, but was expected to fail";
+- nonzero and output does not match → fail with "failed, but not for the
+  expected reason", echoing the output;
+- nonzero and output matches → pass, printing the matched line.
+
+Also replace `$<CONFIGURATION>` with `$<CONFIG>`, add the `xfail-compile`
+label, and set the `RESOURCE_LOCK`.
+
+Acceptance: same 59 pass; the three outcomes above each produce their
+message when provoked (a file that compiles, a file with a syntax error, a
+genuine mandate violation); `ctest -j 8 -L xfail-compile` is clean.
+
+### Stage 3 — [expect-in-source](#expect-in-source)
+
+Make the source comment and the CMake regex agree again, then let the
+module read the comment when `EXPECT` is omitted.
+
+- Update the 15 drifted `// EXPECT:` lines to the CMake regex (the CMake
+  one is the superset that already passes on three compilers) and add the
+  missing 9.
+- Implement the omitted-`EXPECT` path with `file(STRINGS ... REGEX)` at
+  configure time plus `CMAKE_CONFIGURE_DEPENDS` on the source, and a
+  `FATAL_ERROR` when neither an argument nor a comment supplies a regex.
+- Drop the `EXPECT` arguments from the 59 calls in this repo so the
+  comment is the one place the regex lives.
+- Rewrite `docs/plan/tests-overview.md` §3 for the new function and the
+  new rule ("the comment *is* the regex").
+
+Acceptance: 59/59 of the `_fail.test.cpp` files carry an EXPECT comment;
+removing one makes configure fail with a message naming the file.
+
+### Stage 4 — [infra-pr](#infra-pr)
+
+In `~/src/beman-infra/main`: add `upstream` → `bemanproject/infra`, branch,
+copy the module and driver into `cmake/`, add a README section modelled on
+the `beman_install_library` one (usage snippet, argument list, what the
+test does, the label and lock, the EXPECT-from-source rule), run
+pre-commit, open the PR against `bemanproject/infra`. Point at this repo's
+59 uses and optional's one as the implementation experience.
+
+### Stage 5 — [adopt-pin](#adopt-pin)
+
+After the infra PR merges: `beman-submodule update --remote` here, delete
+`cmake/beman-xfail-compile*.cmake`, change the `include()` path to
+`infra/cmake/`, and re-run the Stage 1 acceptance. Then offer
+`beman.optional` a one-test PR that swaps its `WILL_FAIL` for the module
+with a real regex.
+
+Stages 1–3 are a single PR to `bemanproject/expected` (one commit each, or
+squashed; the review unit is the PR). Stage 4 is a PR elsewhere. Stage 5
+is a small follow-up PR here.
+
+## Decisions
+
+Entry shape: Question / Status / Decision / Why / Decided by / Log.
+Divergences append dated lines to the Log of the question they touch.
+
+### module-name
+
+**Question:** What are the module file and function called?
+**Status:** OPEN (recommendation below; final name is the infra reviewers')
+**Decision (proposed):** `beman-xfail-compile.cmake` providing
+`beman_add_xfail_compile_test()`.
+**Why:** Matches `beman-install-library.cmake` / `beman_install_library()`
+in the file-to-function mapping. "xfail" is the established test-suite term
+for "expected to fail" (DejaGnu, pytest, lit); "compile" says which phase.
+"negative test" was rejected because it does not say *compile*.
+**Decided by:** plan author, pending infra review.
+**Log:** 2026-10-19 opened.
+
+### argument-shape
+
+**Question:** Positional `(name source reason)` as today, or keywords?
+**Status:** DECIDED
+**Decision:** Keywords via `cmake_parse_arguments`; `<name>` positional.
+**Why:** Matches `beman_install_library`. Positional would have to grow
+(link targets, definitions, labels) and a third positional regex is already
+hard to read in the 59 call sites. Cost: every call site changes once.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+### build-mechanism
+
+**Question:** Keep the nested `cmake --build --target` or switch to
+`try_compile` / a direct compiler invocation?
+**Status:** DECIDED
+**Decision:** Keep the nested build of an excluded OBJECT library.
+**Why:** It is the only mechanism that inherits the target's full usage
+requirements — include dirs, `cxx_std_23`, module BMIs, toolchain flags,
+compiler launcher — without re-deriving them. `try_compile` at test time
+would need those exported by hand and would silently diverge from the real
+build. Both beman repos that have negative tests already use this form.
+Costs: each test is a `cmake` + `ninja` process pair (acceptable for 59),
+and nested builds in one tree must not run concurrently (see
+[concurrent-nested-builds](#concurrent-nested-builds)).
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+### failure-detection
+
+**Question:** `PASS_REGULAR_EXPRESSION` alone, `WILL_FAIL`, or a driver?
+**Status:** DECIDED
+**Decision:** A `-P` driver script that checks exit status *and* regex.
+**Why:** `WILL_FAIL` alone passes on any failure, including a syntax error
+in the test file (optional's current weakness). `PASS_REGULAR_EXPRESSION`
+alone is what this repo has and it works, but it cannot distinguish "built
+successfully" from "failed for the wrong reason" in its report, and it
+would pass if a *successful* build's output happened to contain the regex
+(a warning quoting the message, say). ctest cannot combine WILL_FAIL with
+a regex check, because WILL_FAIL inverts the whole result. The driver gives
+all three outcomes a distinct message, which is what someone debugging a
+new compiler's phrasing needs. Precedent for a helper script beside the
+module: `telemetry.sh`.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided. Regex reaches the driver as a `-D` value;
+`|` and spaces are fine, `;` is not, and no regex here contains one — the
+module will `FATAL_ERROR` on a `;`.
+
+### expect-authority
+
+**Question:** Which is authoritative, the `// EXPECT:` comment or the CMake
+argument?
+**Status:** DECIDED
+**Decision:** The comment, once reconciled; the argument is an override.
+**Why:** Two copies drift — 24 of 59 already have. The regex is a statement
+about the test file's diagnostic, so it belongs next to the ill-formed
+line it describes, and a reviewer reading one file sees both. CMake reads
+it at configure time cheaply. The argument stays for files the project
+cannot annotate (vendored sources) and for one-off overrides.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided. Reconciliation goes toward the CMake regex,
+not the comment, because the CMake regex is the one proven on gcc, clang,
+and MSVC.
+
+### concurrent-nested-builds
+
+**Question:** Is it safe to run these tests under `ctest -j`?
+**Status:** DECIDED
+**Decision:** Set `RESOURCE_LOCK` on every xfail test so ctest serializes
+them against each other (other tests still run alongside).
+**Why:** Several `ninja` processes in one build directory race on
+`.ninja_log` and `.ninja_deps`. Today's CI and `make test` run ctest
+serially so it has not bitten, but a shared module will be used by repos
+that pass `-j`. A lock is free when serial and correct when not.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+### target-naming
+
+**Question:** How is the per-test object library named?
+**Status:** DECIDED
+**Decision:** `${TARGET_PREFIX}${name}`, default prefix
+`${PROJECT_NAME}.tests.`.
+**Why:** Reproduces `beman.expected.tests.<name>` here with no argument,
+and gives any `beman.<x>` project the same convention automatically. The
+argument exists for projects whose test targets are named otherwise.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+### staging-path
+
+**Question:** Develop the module under `infra/` here, or under `cmake/`?
+**Status:** DECIDED
+**Decision:** Under `cmake/` here first, identical content, then move.
+**Why:** `infra/` is vendored and would be clobbered by the next pin
+update, and a PR here cannot depend on when infra merges. The project-local
+copy is deleted in [adopt-pin](#adopt-pin); the only diff at that point is
+one `include()` path.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+### infra-self-test
+
+**Question:** Should infra gain a test of this module?
+**Status:** OPEN
+**Decision:** None yet. Infra has no module tests today and its CI is
+pre-commit only; a smoke project under `cmake/` would be a new kind of
+thing there. Raise it in the infra PR and let the maintainers choose.
+**Decided by:** —
+**Log:** 2026-10-19 opened.
+
+### find-package-form
+
+**Question:** Offer `find_package(BemanXfailCompile)` like telemetry does?
+**Status:** DECIDED
+**Decision:** No. `include()` only, like `beman_install_library`.
+**Why:** The telemetry Config file exists so the module can be injected via
+`CMAKE_PROJECT_TOP_LEVEL_INCLUDES` into builds that do not know about it.
+A test-registration function is always called from the consuming
+CMakeLists, so there is nothing to inject.
+**Decided by:** plan author.
+**Log:** 2026-10-19 decided.
+
+## Files touched
+
+| Stage | File | Change |
+|---|---|---|
+| module-in-project | `cmake/beman-xfail-compile.cmake` | new |
+| module-in-project | `tests/beman/expected/CMakeLists.txt` | macro removed; 59 calls rewritten |
+| driver-script | `cmake/beman-xfail-compile-driver.cmake` | new |
+| expect-in-source | `tests/beman/expected/*_fail.test.cpp` | 24 EXPECT lines added or aligned |
+| expect-in-source | `docs/plan/tests-overview.md` | §3 rewritten |
+| infra-pr | `bemanproject/infra: cmake/beman-xfail-compile*.cmake`, `README.md` | new module + docs |
+| adopt-pin | `infra/`, `cmake/beman-xfail-compile*.cmake` | pin bumped; local copies deleted |
+
+## Out of scope
+
+- Changing *which* diagnostics the 59 tests expect. Regex text moves; it
+  does not change.
+- Making the negative suite faster by batching translation units. One
+  file per test is what gives each mandate its own named result.
+- beman-tidy rules about negative tests.

From d098640c575b031c4409456d78a938cd7372d14c Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 14:26:05 -0400
Subject: [PATCH 2/9] Replace the add_fail_test macro with a project-local
 beman_add_xfail_compile_test module

cmake/beman-xfail-compile.cmake holds the function in the form intended
for bemanproject/infra: include_guard, a documented keyword interface via
cmake_parse_arguments, and a per-test OBJECT library excluded from the
default build that ctest compiles in a nested build and checks against
EXPECT. The 59 call sites move to the keyword form with their regexes
unchanged; the per-test target names and ctest names are the same as
before. Call sites are laid out as gersemi formats them when it knows the
function definition, so they stay stable once a definitions path is
configured.

Verified: 1249/1249 tests pass on gcc 16 and on clang 23 with libstdc++,
ctest -N lists the same 59 negative test names as before, and breaking
one regex makes exactly that test fail.
---
 cmake/beman-xfail-compile.cmake     | 127 +++++++
 tests/beman/expected/CMakeLists.txt | 542 ++++++++++++++++++----------
 2 files changed, 474 insertions(+), 195 deletions(-)
 create mode 100644 cmake/beman-xfail-compile.cmake

diff --git a/cmake/beman-xfail-compile.cmake b/cmake/beman-xfail-compile.cmake
new file mode 100644
index 0000000..ffd4e6d
--- /dev/null
+++ b/cmake/beman-xfail-compile.cmake
@@ -0,0 +1,127 @@
+# cmake/beman-xfail-compile.cmake                                   -*-CMake-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+include_guard(GLOBAL)
+
+# beman_add_xfail_compile_test
+# ============================
+#
+# Registers a negative compile test: a translation unit that must fail to
+# compile, and must fail with a specific diagnostic.
+#
+# Usage:
+# ------
+#   beman_add_xfail_compile_test(<name>
+#     SOURCE <file>
+#     EXPECT <regex>
+#     [LINK_LIBRARIES <target> ...]
+#     [COMPILE_DEFINITIONS <definition> ...]
+#     [TARGET_PREFIX <prefix>]
+#     [LABELS <label> ...]
+#   )
+#
+# Arguments:
+# ----------
+#
+# name
+#   The CTest test name.
+#
+# SOURCE (required)
+#   The source file that must not compile.
+#
+# EXPECT (required)
+#   A regular expression matched against the compiler output. The test
+#   passes only when the output matches, which confirms the failure is the
+#   intended static_assert, deleted overload, or constraint, and not an
+#   unrelated build error. Alternations such as
+#   "use of deleted function|call to deleted" cover compiler phrasings.
+#
+# LINK_LIBRARIES (optional)
+#   Targets whose usage requirements the source is compiled with, typically
+#   the library under test. Nothing is ever linked.
+#
+# COMPILE_DEFINITIONS (optional)
+#   Extra preprocessor definitions for the source.
+#
+# TARGET_PREFIX (optional)
+#   Prefix of the per-test CMake target. Defaults to "${PROJECT_NAME}.tests."
+#   so beman.<lib> gets beman.<lib>.tests.<name>.
+#
+# LABELS (optional)
+#   CTest labels to attach to the test.
+#
+# Brief
+# -----
+#
+# The source becomes an OBJECT library that is excluded from the default
+# build, so an ordinary build never compiles it and nothing links it. The
+# test itself is a nested build of just that target, which compiles the
+# source with exactly the toolchain, flags, launcher, and usage
+# requirements the rest of the project gets. CTest then requires the
+# build output to match EXPECT.
+
+function(beman_add_xfail_compile_test name)
+    set(oneValueArgs SOURCE EXPECT TARGET_PREFIX)
+    set(multiValueArgs LINK_LIBRARIES COMPILE_DEFINITIONS LABELS)
+    cmake_parse_arguments(
+        BEMAN_XFAIL
+        ""
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+
+    if(BEMAN_XFAIL_UNPARSED_ARGUMENTS)
+        message(
+            FATAL_ERROR
+            "beman_add_xfail_compile_test(${name}): unexpected arguments '${BEMAN_XFAIL_UNPARSED_ARGUMENTS}'"
+        )
+    endif()
+    if(NOT BEMAN_XFAIL_SOURCE)
+        message(
+            FATAL_ERROR
+            "beman_add_xfail_compile_test(${name}): SOURCE must be specified"
+        )
+    endif()
+    if(NOT BEMAN_XFAIL_EXPECT)
+        message(
+            FATAL_ERROR
+            "beman_add_xfail_compile_test(${name}): EXPECT must be specified"
+        )
+    endif()
+    if(NOT DEFINED BEMAN_XFAIL_TARGET_PREFIX)
+        set(BEMAN_XFAIL_TARGET_PREFIX "${PROJECT_NAME}.tests.")
+    endif()
+
+    set(_target "${BEMAN_XFAIL_TARGET_PREFIX}${name}")
+
+    add_library(${_target} OBJECT)
+    target_sources(${_target} PRIVATE ${BEMAN_XFAIL_SOURCE})
+    if(BEMAN_XFAIL_LINK_LIBRARIES)
+        target_link_libraries(${_target} PRIVATE ${BEMAN_XFAIL_LINK_LIBRARIES})
+    endif()
+    if(BEMAN_XFAIL_COMPILE_DEFINITIONS)
+        target_compile_definitions(
+            ${_target}
+            PRIVATE ${BEMAN_XFAIL_COMPILE_DEFINITIONS}
+        )
+    endif()
+    set_target_properties(
+        ${_target}
+        PROPERTIES EXCLUDE_FROM_ALL true EXCLUDE_FROM_DEFAULT_BUILD true
+    )
+
+    add_test(
+        NAME ${name}
+        COMMAND
+            ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}" --target ${_target}
+            --config $<CONFIGURATION>
+    )
+    set_tests_properties(
+        ${name}
+        PROPERTIES PASS_REGULAR_EXPRESSION "${BEMAN_XFAIL_EXPECT}"
+    )
+    if(BEMAN_XFAIL_LABELS)
+        set_tests_properties(${name} PROPERTIES LABELS "${BEMAN_XFAIL_LABELS}")
+    endif()
+endfunction()
diff --git a/tests/beman/expected/CMakeLists.txt b/tests/beman/expected/CMakeLists.txt
index 21250ec..38b7eca 100644
--- a/tests/beman/expected/CMakeLists.txt
+++ b/tests/beman/expected/CMakeLists.txt
@@ -145,284 +145,436 @@ if(NOT BEMAN_EXPECTED_USING_LIBCXX)
 endif()
 
 # =============================================================================
-# Negative compile tests (WILL_FAIL = compile failure is the expected outcome)
+# Negative compile tests: compile failure with a specific diagnostic is the
+# expected outcome. See cmake/beman-xfail-compile.cmake.
 # =============================================================================
 
-# Helper macro: negative compile test that must fail with a specific diagnostic.
-# The 'reason' is a regex matched against compiler output — confirms the failure
-# is the intended static_assert / constraint, not an unrelated build error.
-macro(add_fail_test name source reason)
-    add_library(beman.expected.tests.${name} OBJECT)
-    target_sources(beman.expected.tests.${name} PRIVATE ${source})
-    target_link_libraries(beman.expected.tests.${name} PRIVATE beman::expected)
-    set_target_properties(
-        beman.expected.tests.${name}
-        PROPERTIES EXCLUDE_FROM_ALL true EXCLUDE_FROM_DEFAULT_BUILD true
-    )
-    add_test(
-        NAME ${name}
-        COMMAND
-            ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}" --target
-            beman.expected.tests.${name} --config $<CONFIGURATION>
-    )
-    set_tests_properties(${name} PROPERTIES PASS_REGULAR_EXPRESSION "${reason}")
-endmacro()
+include(${PROJECT_SOURCE_DIR}/cmake/beman-xfail-compile.cmake)
 
 # Step 1 — unexpected<E> ill-formed instantiations [expected.un.general]
-add_fail_test(unexpected_array_fail unexpected_array_fail.test.cpp
-    "E must not be an array type"
+beman_add_xfail_compile_test(
+    unexpected_array_fail
+    SOURCE unexpected_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
 )
-add_fail_test(unexpected_cvref_fail unexpected_cvref_fail.test.cpp
-    "E must not be cv-qualified"
+beman_add_xfail_compile_test(
+    unexpected_cvref_fail
+    SOURCE unexpected_cvref_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be cv-qualified"
 )
-add_fail_test(unexpected_self_fail  unexpected_self_fail.test.cpp
-    "E must not be a specialization of unexpected"
+beman_add_xfail_compile_test(
+    unexpected_self_fail
+    SOURCE unexpected_self_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be a specialization of unexpected"
 )
 
 # Step 3 — expected<T,E> ill-formed T/E [expected.object.general]
-add_fail_test(expected_t_ref_fail   expected_t_ref_fail.test.cpp
-    "no default constructor|use of deleted function|call to deleted|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_t_ref_fail
+    SOURCE expected_t_ref_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no default constructor|use of deleted function|call to deleted|attempting to reference"
 )
 # Note: expected_e_ref_fail removed — expected<int, int&> is now valid via expected<T,E&>
-add_fail_test(expected_t_array_fail expected_t_array_fail.test.cpp
-    "T must not be an array type"
+beman_add_xfail_compile_test(
+    expected_t_array_fail
+    SOURCE expected_t_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be an array type"
 )
 
 # Step 3 — expected<T,E> emplace Mandates: nothrow_constructible_v<T,Args...>
-add_fail_test(expected_emplace_throwing_fail expected_emplace_throwing_fail.test.cpp
-    "is_nothrow_constructible|no matching overloaded function found"
+beman_add_xfail_compile_test(
+    expected_emplace_throwing_fail
+    SOURCE expected_emplace_throwing_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "is_nothrow_constructible|no matching overloaded function found"
 )
 
 # Step 4 — expected<void,E> ill-formed E [expected.void.general]
 # Note: expected_void_ref_fail.cpp is removed — expected<void, E&> is now valid via
 # the expected<void, E&> specialization added in Step 10.
-add_fail_test(expected_void_array_fail expected_void_array_fail.test.cpp
-    "E must not be an array type"
+beman_add_xfail_compile_test(
+    expected_void_array_fail
+    SOURCE expected_void_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
 )
 
 # Step 5 — monadic Mandates [expected.object.monadic]
-add_fail_test(and_then_wrong_error_type_fail    and_then_wrong_error_type_fail.test.cpp
-    "F must return expected with the same error_type"
-)
-add_fail_test(and_then_not_expected_fail        and_then_not_expected_fail.test.cpp
-    "F must return a specialization of expected"
-)
-add_fail_test(or_else_wrong_value_type_fail     or_else_wrong_value_type_fail.test.cpp
-    "F must return expected with the same value_type"
-)
-add_fail_test(transform_error_ref_result_fail   transform_error_ref_result_fail.test.cpp
-    "G must be an object type"
+beman_add_xfail_compile_test(
+    and_then_wrong_error_type_fail
+    SOURCE and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same error_type"
+)
+beman_add_xfail_compile_test(
+    and_then_not_expected_fail
+    SOURCE and_then_not_expected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return a specialization of expected"
+)
+beman_add_xfail_compile_test(
+    or_else_wrong_value_type_fail
+    SOURCE or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same value_type"
+)
+beman_add_xfail_compile_test(
+    transform_error_ref_result_fail
+    SOURCE transform_error_ref_result_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "G must be an object type"
 )
 
 # Step 6 — void monadic Mandates [expected.void.monadic]
-add_fail_test(void_and_then_wrong_error_type_fail void_and_then_wrong_error_type_fail.test.cpp
-    "F must return expected with the same error_type"
+beman_add_xfail_compile_test(
+    void_and_then_wrong_error_type_fail
+    SOURCE void_and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same error_type"
 )
-add_fail_test(void_or_else_wrong_value_type_fail  void_or_else_wrong_value_type_fail.test.cpp
-    "F must return expected with the same value_type"
+beman_add_xfail_compile_test(
+    void_or_else_wrong_value_type_fail
+    SOURCE void_or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same value_type"
 )
 
 # Fix 1 — constraint 23.6: value ctor blocked for T=bool, U=expected specialization
-add_fail_test(expected_bool_value_ctor_from_expected_fail expected_bool_value_ctor_from_expected_fail.test.cpp
-    "no matching function|no matching constructor|no overloaded function could convert"
+beman_add_xfail_compile_test(
+    expected_bool_value_ctor_from_expected_fail
+    SOURCE expected_bool_value_ctor_from_expected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no matching function|no matching constructor|no overloaded function could convert"
 )
 
 # Fix 4 — Mandates: T must not be a specialization of unexpected
-add_fail_test(expected_unexpected_value_type_fail expected_unexpected_value_type_fail.test.cpp
-    "T must not be a specialization of unexpected"
+beman_add_xfail_compile_test(
+    expected_unexpected_value_type_fail
+    SOURCE expected_unexpected_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be a specialization of unexpected"
 )
 
 # Step 7 — expected<T&, E> reference specialization: constructor constraints
-add_fail_test(expected_ref_temporary_fail     expected_ref_temporary_fail.test.cpp
-    "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
-)
-add_fail_test(expected_ref_no_default_fail    expected_ref_no_default_fail.test.cpp
-    "no default constructor|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_ref_inplace_value_fail expected_ref_inplace_value_fail.test.cpp
-    "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_temporary_fail
+    SOURCE expected_ref_temporary_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_no_default_fail
+    SOURCE expected_ref_no_default_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no default constructor|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_inplace_value_fail
+    SOURCE expected_ref_inplace_value_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 8 — expected<T, E&> reference error: dangling prevention
-add_fail_test(expected_ref_e_temporary_error_fail expected_ref_e_temporary_error_fail.test.cpp
-    "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_e_temporary_error_fail
+    SOURCE expected_ref_e_temporary_error_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
-add_fail_test(expected_ref_e_const_lvalue_fail expected_ref_e_const_lvalue_fail.test.cpp
-    "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_e_const_lvalue_fail
+    SOURCE expected_ref_e_const_lvalue_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 8 — expected<T, E&>: no constructor or assignment from unexpected<G>
 # (would bind E& to storage inside the temporary unexpected — dangling)
-add_fail_test(expected_ref_e_construct_from_unexpected_fail
-    expected_ref_e_construct_from_unexpected_fail.test.cpp
-    "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_e_construct_from_unexpected_fail
+    SOURCE expected_ref_e_construct_from_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
 )
-add_fail_test(expected_ref_e_assign_unexpected_fail
-    expected_ref_e_assign_unexpected_fail.test.cpp
-    "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_e_assign_unexpected_fail
+    SOURCE expected_ref_e_assign_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
 )
 
 # Step 7/8 parity — expected<T&,E> or_else value_type mandate (added in Step 8 review)
-add_fail_test(expected_ref_or_else_wrong_value_type_fail expected_ref_or_else_wrong_value_type_fail.test.cpp
-    "F must return expected with the same value_type"
+beman_add_xfail_compile_test(
+    expected_ref_or_else_wrong_value_type_fail
+    SOURCE expected_ref_or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same value_type"
 )
 
 # Step 9 — expected<T&, E&> dangling prevention and no-default constraint
-add_fail_test(expected_ref_both_temporary_val_fail expected_ref_both_temporary_val_fail.test.cpp
-    "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
-)
-add_fail_test(expected_ref_both_temporary_err_fail expected_ref_both_temporary_err_fail.test.cpp
-    "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_ref_both_no_default_fail expected_ref_both_no_default_fail.test.cpp
-    "no default constructor|use of deleted function|call to deleted|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_both_temporary_val_fail
+    SOURCE expected_ref_both_temporary_val_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_temporary_err_fail
+    SOURCE expected_ref_both_temporary_err_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_no_default_fail
+    SOURCE expected_ref_both_no_default_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no default constructor|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 9 — expected<T&, E&>: no constructor or assignment from unexpected<G>
 # (would bind E& to storage inside the temporary unexpected — dangling)
-add_fail_test(expected_ref_both_construct_from_unexpected_fail
-    expected_ref_both_construct_from_unexpected_fail.test.cpp
-    "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_both_construct_from_unexpected_fail
+    SOURCE expected_ref_both_construct_from_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
 )
-add_fail_test(expected_ref_both_assign_unexpected_fail
-    expected_ref_both_assign_unexpected_fail.test.cpp
-    "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
+beman_add_xfail_compile_test(
+    expected_ref_both_assign_unexpected_fail
+    SOURCE expected_ref_both_assign_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
 )
 
 # Step 9 — expected<T&, E&>: or_else value_type mandate
-add_fail_test(expected_ref_both_or_else_wrong_value_type_fail
-    expected_ref_both_or_else_wrong_value_type_fail.test.cpp
-    "F must return expected with the same value_type"
+beman_add_xfail_compile_test(
+    expected_ref_both_or_else_wrong_value_type_fail
+    SOURCE expected_ref_both_or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same value_type"
 )
 
 # Step 7 — expected<T&, E> Mandates: E constraints
-add_fail_test(expected_ref_e_ref_fail   expected_ref_e_ref_fail.test.cpp
-    "E must not be an rvalue reference"
-)
-add_fail_test(expected_ref_e_void_fail  expected_ref_e_void_fail.test.cpp
-    "E must not be void"
-)
-add_fail_test(expected_ref_e_array_fail expected_ref_e_array_fail.test.cpp
-    "E must not be an array type"
-)
-add_fail_test(expected_ref_e_cv_fail    expected_ref_e_cv_fail.test.cpp
-    "E must not be cv-qualified"
+beman_add_xfail_compile_test(
+    expected_ref_e_ref_fail
+    SOURCE expected_ref_e_ref_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an rvalue reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_void_fail
+    SOURCE expected_ref_e_void_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be void"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_array_fail
+    SOURCE expected_ref_e_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_cv_fail
+    SOURCE expected_ref_e_cv_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be cv-qualified"
 )
 
 # Step 7 — expected<T&, E> monadic mandates
-add_fail_test(expected_ref_and_then_wrong_error_type_fail
-    expected_ref_and_then_wrong_error_type_fail.test.cpp
-    "F must return expected with the same error_type"
+beman_add_xfail_compile_test(
+    expected_ref_and_then_wrong_error_type_fail
+    SOURCE expected_ref_and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same error_type"
 )
-add_fail_test(expected_ref_transform_error_ref_result_fail
-    expected_ref_transform_error_ref_result_fail.test.cpp
-    "G must be an object type"
+beman_add_xfail_compile_test(
+    expected_ref_transform_error_ref_result_fail
+    SOURCE expected_ref_transform_error_ref_result_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "G must be an object type"
 )
 
 # Step 8 — expected<T, E&> Mandates: T and E type constraints
-add_fail_test(expected_ref_e_t_array_fail
-    expected_ref_e_t_array_fail.test.cpp
-    "T must not be an array type"
-)
-add_fail_test(expected_ref_e_e_array_fail
-    expected_ref_e_e_array_fail.test.cpp
-    "E must not be an array type"
-)
-add_fail_test(expected_ref_e_t_inplace_fail
-    expected_ref_e_t_inplace_fail.test.cpp
-    "T must not be in_place_t"
-)
-add_fail_test(expected_ref_e_t_unexpect_fail
-    expected_ref_e_t_unexpect_fail.test.cpp
-    "T must not be unexpect_t"
-)
-add_fail_test(expected_ref_e_t_unexpected_fail
-    expected_ref_e_t_unexpected_fail.test.cpp
-    "T must not be a specialization of unexpected"
-)
-add_fail_test(expected_ref_e_initializer_list_fail
-    expected_ref_e_initializer_list_fail.test.cpp
-    "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
+beman_add_xfail_compile_test(
+    expected_ref_e_t_array_fail
+    SOURCE expected_ref_e_t_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be an array type"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_e_array_fail
+    SOURCE expected_ref_e_e_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_t_inplace_fail
+    SOURCE expected_ref_e_t_inplace_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be in_place_t"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_t_unexpect_fail
+    SOURCE expected_ref_e_t_unexpect_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be unexpect_t"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_t_unexpected_fail
+    SOURCE expected_ref_e_t_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be a specialization of unexpected"
+)
+beman_add_xfail_compile_test(
+    expected_ref_e_initializer_list_fail
+    SOURCE expected_ref_e_initializer_list_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # Step 8 — expected<T, E&> monadic mandates
-add_fail_test(expected_ref_e_and_then_wrong_error_type_fail
-    expected_ref_e_and_then_wrong_error_type_fail.test.cpp
-    "F must return expected with the same error_type"
+beman_add_xfail_compile_test(
+    expected_ref_e_and_then_wrong_error_type_fail
+    SOURCE expected_ref_e_and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same error_type"
 )
-add_fail_test(expected_ref_e_or_else_wrong_value_type_fail
-    expected_ref_e_or_else_wrong_value_type_fail.test.cpp
-    "F must return expected with the same value_type"
+beman_add_xfail_compile_test(
+    expected_ref_e_or_else_wrong_value_type_fail
+    SOURCE expected_ref_e_or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same value_type"
 )
-add_fail_test(expected_ref_e_transform_error_ref_result_fail
-    expected_ref_e_transform_error_ref_result_fail.test.cpp
-    "G must be an object type"
+beman_add_xfail_compile_test(
+    expected_ref_e_transform_error_ref_result_fail
+    SOURCE expected_ref_e_transform_error_ref_result_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "G must be an object type"
 )
 
 # Step 9 — expected<T&, E&> Mandates: T and E type constraints
-add_fail_test(expected_ref_both_t_array_fail
-    expected_ref_both_t_array_fail.test.cpp
-    "T must not be an array type"
-)
-add_fail_test(expected_ref_both_e_array_fail
-    expected_ref_both_e_array_fail.test.cpp
-    "E must not be an array type"
-)
-add_fail_test(expected_ref_both_t_inplace_fail
-    expected_ref_both_t_inplace_fail.test.cpp
-    "T must not be in_place_t"
-)
-add_fail_test(expected_ref_both_t_unexpect_fail
-    expected_ref_both_t_unexpect_fail.test.cpp
-    "T must not be unexpect_t"
-)
-add_fail_test(expected_ref_both_t_unexpected_fail
-    expected_ref_both_t_unexpected_fail.test.cpp
-    "T must not be a specialization of unexpected"
-)
-add_fail_test(expected_ref_both_inplace_value_fail
-    expected_ref_both_inplace_value_fail.test.cpp
-    "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_ref_both_initializer_list_fail
-    expected_ref_both_initializer_list_fail.test.cpp
-    "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
+beman_add_xfail_compile_test(
+    expected_ref_both_t_array_fail
+    SOURCE expected_ref_both_t_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be an array type"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_e_array_fail
+    SOURCE expected_ref_both_e_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "E must not be an array type"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_inplace_fail
+    SOURCE expected_ref_both_t_inplace_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be in_place_t"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_unexpect_fail
+    SOURCE expected_ref_both_t_unexpect_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be unexpect_t"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_unexpected_fail
+    SOURCE expected_ref_both_t_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "T must not be a specialization of unexpected"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_inplace_value_fail
+    SOURCE expected_ref_both_inplace_value_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_initializer_list_fail
+    SOURCE expected_ref_both_initializer_list_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # Step 9 — expected<T&, E&> monadic mandates
-add_fail_test(expected_ref_both_and_then_wrong_error_type_fail
-    expected_ref_both_and_then_wrong_error_type_fail.test.cpp
-    "F must return expected with the same error_type"
+beman_add_xfail_compile_test(
+    expected_ref_both_and_then_wrong_error_type_fail
+    SOURCE expected_ref_both_and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "F must return expected with the same error_type"
 )
-add_fail_test(expected_ref_both_transform_error_ref_result_fail
-    expected_ref_both_transform_error_ref_result_fail.test.cpp
-    "G must be an object type"
+beman_add_xfail_compile_test(
+    expected_ref_both_transform_error_ref_result_fail
+    SOURCE expected_ref_both_transform_error_ref_result_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT "G must be an object type"
 )
 
 # Step 10 — expected<void, E&> dangling prevention and no value_or
-add_fail_test(expected_void_ref_e_temporary_fail
-    expected_void_ref_e_temporary_fail.test.cpp
-    "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_void_ref_e_const_lvalue_fail
-    expected_void_ref_e_const_lvalue_fail.test.cpp
-    "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_void_ref_e_no_value_or_fail
-    expected_void_ref_e_no_value_or_fail.test.cpp
-    "no value_or for void|use of deleted function|call to deleted|attempting to reference"
-)
-add_fail_test(expected_void_ref_e_construct_from_unexpected_fail
-    expected_void_ref_e_construct_from_unexpected_fail.test.cpp
-    "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
-)
-add_fail_test(expected_void_ref_e_assign_unexpected_fail
-    expected_void_ref_e_assign_unexpected_fail.test.cpp
-    "no assignment from unexpected|use of deleted function|call to deleted|invokes a deleted function|selected deleted operator|attempting to reference"
-)
-add_fail_test(expected_void_ref_e_initializer_list_fail
-    expected_void_ref_e_initializer_list_fail.test.cpp
-    "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
+beman_add_xfail_compile_test(
+    expected_void_ref_e_temporary_fail
+    SOURCE expected_void_ref_e_temporary_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_void_ref_e_const_lvalue_fail
+    SOURCE expected_void_ref_e_const_lvalue_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_void_ref_e_no_value_or_fail
+    SOURCE expected_void_ref_e_no_value_or_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no value_or for void|use of deleted function|call to deleted|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_void_ref_e_construct_from_unexpected_fail
+    SOURCE expected_void_ref_e_construct_from_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_void_ref_e_assign_unexpected_fail
+    SOURCE expected_void_ref_e_assign_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "no assignment from unexpected|use of deleted function|call to deleted|invokes a deleted function|selected deleted operator|attempting to reference"
+)
+beman_add_xfail_compile_test(
+    expected_void_ref_e_initializer_list_fail
+    SOURCE expected_void_ref_e_initializer_list_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+    EXPECT
+        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # =============================================================================

From 9ca1f37f66e68542bc5775df24cafcf14067b3fe Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 14:26:05 -0400
Subject: [PATCH 3/9] Record stage module-in-project as done in the extraction
 plan

---
 docs/plan/extract-xfail-compile.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
index 39cd417..f8a84f1 100644
--- a/docs/plan/extract-xfail-compile.md
+++ b/docs/plan/extract-xfail-compile.md
@@ -153,6 +153,13 @@ deliberately broken regex on one test makes that one test fail.
 
 This stage is mergeable to `main` on its own and does not wait on infra.
 
+**Status:** DONE 2026-10-19. Log: call sites use gersemi's
+definition-aware layout (`--definitions cmake/beman-xfail-compile.cmake`),
+which also passes a plain `gersemi --check`. The `make lint` gate is read
+as "every hook except beman-tidy's pre-existing failures", which clean
+`main` shows too; they come from `.venv`/`.build` contents and the
+repository name, not from these files.
+
 ### Stage 2 — [driver-script](#driver-script)
 
 Add `cmake/beman-xfail-compile-driver.cmake` and have the module's

From c118b0abd91c69ccc8637655fbf7f1f9b16a46e2 Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 14:52:02 -0400
Subject: [PATCH 4/9] Run negative compile tests through a driver that tells a
 compile from a wrong failure

beman-xfail-compile-driver.cmake performs the nested build itself and
exits nonzero with a distinct report when the source compiled, and when it
failed without a line matching EXPECT; on success it prints the matched
diagnostic. PASS_REGULAR_EXPRESSION alone could not tell the first two
apart and would have passed a successful build whose output happened to
contain the regex.

Each test also gets the label xfail-compile, so the negative suite can be
selected or skipped with -L/-LE, and the RESOURCE_LOCK
beman-xfail-compile-build-tree, so ctest -j never runs two nested builds
in one tree at once. The config reaches the driver as $<CONFIG>, in place
of the deprecated $<CONFIGURATION>, and is omitted from the nested build
when empty. EXPECT may not contain ';', which would split on the way to
the driver.

Verified on gcc 16: a source that compiles and a source with a syntax
error each fail with their own message, the 59 real tests pass with
-L xfail-compile -j 8, and the full suite passes on clang 23 with
libstdc++.
---
 cmake/beman-xfail-compile-driver.cmake | 68 ++++++++++++++++++++++++++
 cmake/beman-xfail-compile.cmake        | 40 ++++++++++-----
 2 files changed, 97 insertions(+), 11 deletions(-)
 create mode 100644 cmake/beman-xfail-compile-driver.cmake

diff --git a/cmake/beman-xfail-compile-driver.cmake b/cmake/beman-xfail-compile-driver.cmake
new file mode 100644
index 0000000..c62c120
--- /dev/null
+++ b/cmake/beman-xfail-compile-driver.cmake
@@ -0,0 +1,68 @@
+# cmake/beman-xfail-compile-driver.cmake                            -*-CMake-*-
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# Test driver for beman_add_xfail_compile_test(). Run by CTest as
+#
+#   cmake -DBEMAN_XFAIL_BUILD_DIR=<build dir>
+#         -DBEMAN_XFAIL_TARGET=<object library>
+#         -DBEMAN_XFAIL_CONFIG=<config or empty>
+#         -DBEMAN_XFAIL_EXPECT=<regex>
+#         -P beman-xfail-compile-driver.cmake
+#
+# It builds just the target and succeeds only when the build fails and its
+# output matches the regex. The three outcomes get three distinct reports:
+# the source compiled when it should not have; it failed, but not with the
+# expected diagnostic; or it failed with the expected diagnostic.
+
+cmake_minimum_required(VERSION 3.30...4.3)
+
+foreach(_var BEMAN_XFAIL_BUILD_DIR BEMAN_XFAIL_TARGET BEMAN_XFAIL_EXPECT)
+    if(NOT DEFINED ${_var} OR "${${_var}}" STREQUAL "")
+        message(FATAL_ERROR "beman-xfail-compile-driver: ${_var} is required")
+    endif()
+endforeach()
+
+set(_build_args
+    --build
+    "${BEMAN_XFAIL_BUILD_DIR}"
+    --target
+    "${BEMAN_XFAIL_TARGET}"
+)
+if(BEMAN_XFAIL_CONFIG)
+    list(APPEND _build_args --config "${BEMAN_XFAIL_CONFIG}")
+endif()
+
+execute_process(
+    COMMAND ${CMAKE_COMMAND} ${_build_args}
+    RESULT_VARIABLE _result
+    OUTPUT_VARIABLE _output
+    ERROR_VARIABLE _output
+)
+
+if(_result EQUAL 0)
+    message(
+        FATAL_ERROR
+        "beman-xfail-compile-driver: ${BEMAN_XFAIL_TARGET} compiled, but was expected to fail with a diagnostic matching\n"
+        "    ${BEMAN_XFAIL_EXPECT}\n"
+        "Build output:\n${_output}"
+    )
+endif()
+
+if(NOT _output MATCHES "${BEMAN_XFAIL_EXPECT}")
+    message(
+        FATAL_ERROR
+        "beman-xfail-compile-driver: ${BEMAN_XFAIL_TARGET} failed to compile, but not for the expected reason. No line matches\n"
+        "    ${BEMAN_XFAIL_EXPECT}\n"
+        "Build output:\n${_output}"
+    )
+endif()
+
+string(
+    REGEX MATCH "[^\n]*(${BEMAN_XFAIL_EXPECT})[^\n]*"
+    _matched_line
+    "${_output}"
+)
+message(
+    STATUS
+    "beman-xfail-compile-driver: ${BEMAN_XFAIL_TARGET} failed as expected: ${_matched_line}"
+)
diff --git a/cmake/beman-xfail-compile.cmake b/cmake/beman-xfail-compile.cmake
index ffd4e6d..9426d49 100644
--- a/cmake/beman-xfail-compile.cmake
+++ b/cmake/beman-xfail-compile.cmake
@@ -48,17 +48,27 @@ include_guard(GLOBAL)
 #   so beman.<lib> gets beman.<lib>.tests.<name>.
 #
 # LABELS (optional)
-#   CTest labels to attach to the test.
+#   CTest labels to attach to the test, in addition to "xfail-compile",
+#   which every test gets so `ctest -L xfail-compile` runs just the
+#   negative suite and `ctest -LE xfail-compile` skips it.
 #
 # Brief
 # -----
 #
 # The source becomes an OBJECT library that is excluded from the default
 # build, so an ordinary build never compiles it and nothing links it. The
-# test itself is a nested build of just that target, which compiles the
-# source with exactly the toolchain, flags, launcher, and usage
-# requirements the rest of the project gets. CTest then requires the
-# build output to match EXPECT.
+# test runs beman-xfail-compile-driver.cmake, which performs a nested build
+# of just that target, so the source is compiled with exactly the
+# toolchain, flags, launcher, and usage requirements the rest of the
+# project gets. The driver passes only when that build fails and its
+# output matches EXPECT, and it reports the two ways of failing
+# separately: the source compiled, or it failed for some other reason.
+#
+# Every test holds the RESOURCE_LOCK "beman-xfail-compile-build-tree", so
+# under `ctest -j` the nested builds never run concurrently in one build
+# tree. Other tests still run alongside them.
+#
+# EXPECT is a CMake regular expression and must not contain ";".
 
 function(beman_add_xfail_compile_test name)
     set(oneValueArgs SOURCE EXPECT TARGET_PREFIX)
@@ -89,6 +99,13 @@ function(beman_add_xfail_compile_test name)
             "beman_add_xfail_compile_test(${name}): EXPECT must be specified"
         )
     endif()
+    string(FIND "${BEMAN_XFAIL_EXPECT}" ";" _semicolon)
+    if(NOT _semicolon EQUAL -1)
+        message(
+            FATAL_ERROR
+            "beman_add_xfail_compile_test(${name}): EXPECT must not contain ';'"
+        )
+    endif()
     if(NOT DEFINED BEMAN_XFAIL_TARGET_PREFIX)
         set(BEMAN_XFAIL_TARGET_PREFIX "${PROJECT_NAME}.tests.")
     endif()
@@ -114,14 +131,15 @@ function(beman_add_xfail_compile_test name)
     add_test(
         NAME ${name}
         COMMAND
-            ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}" --target ${_target}
-            --config $<CONFIGURATION>
+            ${CMAKE_COMMAND} -DBEMAN_XFAIL_BUILD_DIR=${CMAKE_BINARY_DIR}
+            -DBEMAN_XFAIL_TARGET=${_target} -DBEMAN_XFAIL_CONFIG=$<CONFIG>
+            -DBEMAN_XFAIL_EXPECT=${BEMAN_XFAIL_EXPECT} -P
+            ${CMAKE_CURRENT_FUNCTION_LIST_DIR}/beman-xfail-compile-driver.cmake
     )
     set_tests_properties(
         ${name}
-        PROPERTIES PASS_REGULAR_EXPRESSION "${BEMAN_XFAIL_EXPECT}"
+        PROPERTIES
+            LABELS "xfail-compile;${BEMAN_XFAIL_LABELS}"
+            RESOURCE_LOCK beman-xfail-compile-build-tree
     )
-    if(BEMAN_XFAIL_LABELS)
-        set_tests_properties(${name} PROPERTIES LABELS "${BEMAN_XFAIL_LABELS}")
-    endif()
 endfunction()

From c2135e509bfee5de5bc927f206eac0c906d926e3 Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 14:52:02 -0400
Subject: [PATCH 5/9] Record stage driver-script as done in the extraction plan

---
 docs/plan/extract-xfail-compile.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
index f8a84f1..d23aeb8 100644
--- a/docs/plan/extract-xfail-compile.md
+++ b/docs/plan/extract-xfail-compile.md
@@ -178,6 +178,11 @@ Acceptance: same 59 pass; the three outcomes above each produce their
 message when provoked (a file that compiles, a file with a syntax error, a
 genuine mandate violation); `ctest -j 8 -L xfail-compile` is clean.
 
+**Status:** DONE 2026-10-19. Log: the driver omits `--config` when
+`$<CONFIG>` is empty (single-config generators). Catch2 tests are
+discovered at ctest time, so `ctest -LE xfail-compile -N` undercounts;
+`-LE` still runs the right set.
+
 ### Stage 3 — [expect-in-source](#expect-in-source)
 
 Make the source comment and the CMake regex agree again, then let the

From 5d5a48b3d90c49269f016b3231f751ed6c8db30d Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 15:07:10 -0400
Subject: [PATCH 6/9] Read each negative test's expected diagnostic from its
 own EXPECT comment

The regex that names a negative test's intended diagnostic now lives only
in the test source, as one or more '// EXPECT: "<regex>"' lines that
beman_add_xfail_compile_test reads at configure time and joins with '|'.
The 59 call sites drop their EXPECT arguments; passing one still
overrides the comment. Configure re-runs when a test source changes, and
fails naming the test and file when a source has no EXPECT line.

Of the 59 sources, 35 already carried the exact regex, 15 carried an
older subset, and 9 had none. All now carry the regex that CMake used,
which is the one proven on gcc, clang, and MSVC. The six files that
described themselves with a prose comment or not at all get a NEGATIVE
line like the rest. Alternations longer than clang-format's 119-column
limit are split across EXPECT lines at an alternative boundary, because
clang-format reflows a longer comment and merges it into the comment
that follows.

Verified: every regex ctest receives is byte-identical to the one the
call site used to pass; 1249/1249 tests pass on gcc 16 and on clang 23
with libstdc++; removing an EXPECT line fails configure with a message
naming the test and file; touching a test source re-runs configure.
Section 3 of docs/plan/tests-overview.md describes the new rule.
---
 cmake/beman-xfail-compile.cmake               | 49 ++++++++++-
 docs/plan/tests-overview.md                   | 68 ++++++++-------
 tests/beman/expected/CMakeLists.txt           | 82 -------------------
 ...ool_value_ctor_from_expected_fail.test.cpp |  2 +-
 .../expected_emplace_throwing_fail.test.cpp   |  2 +-
 ...d_ref_both_assign_unexpected_fail.test.cpp |  3 +-
 ...th_construct_from_unexpected_fail.test.cpp |  3 +-
 ...ed_ref_both_initializer_list_fail.test.cpp |  2 +
 ...ected_ref_both_inplace_value_fail.test.cpp |  2 +-
 ...expected_ref_both_no_default_fail.test.cpp |  3 +-
 ...ected_ref_both_temporary_err_fail.test.cpp |  3 +-
 ...ected_ref_both_temporary_val_fail.test.cpp |  4 +-
 ...cted_ref_e_assign_unexpected_fail.test.cpp |  3 +-
 .../expected_ref_e_const_lvalue_fail.test.cpp |  2 +-
 ..._e_construct_from_unexpected_fail.test.cpp |  3 +-
 ...ected_ref_e_initializer_list_fail.test.cpp |  2 +
 ...pected_ref_e_temporary_error_fail.test.cpp |  2 +-
 .../expected_ref_inplace_value_fail.test.cpp  |  2 +-
 .../expected_ref_no_default_fail.test.cpp     |  2 +-
 .../expected_ref_temporary_fail.test.cpp      |  3 +-
 .../expected/expected_t_ref_fail.test.cpp     |  2 +-
 ...void_ref_e_assign_unexpected_fail.test.cpp |  3 +-
 ...cted_void_ref_e_const_lvalue_fail.test.cpp |  1 +
 ..._e_construct_from_unexpected_fail.test.cpp |  3 +-
 ..._void_ref_e_initializer_list_fail.test.cpp |  2 +
 ...ected_void_ref_e_no_value_or_fail.test.cpp |  1 +
 ...xpected_void_ref_e_temporary_fail.test.cpp |  1 +
 27 files changed, 122 insertions(+), 133 deletions(-)

diff --git a/cmake/beman-xfail-compile.cmake b/cmake/beman-xfail-compile.cmake
index 9426d49..4cc4d65 100644
--- a/cmake/beman-xfail-compile.cmake
+++ b/cmake/beman-xfail-compile.cmake
@@ -13,7 +13,7 @@ include_guard(GLOBAL)
 # ------
 #   beman_add_xfail_compile_test(<name>
 #     SOURCE <file>
-#     EXPECT <regex>
+#     [EXPECT <regex>]
 #     [LINK_LIBRARIES <target> ...]
 #     [COMPILE_DEFINITIONS <definition> ...]
 #     [TARGET_PREFIX <prefix>]
@@ -29,13 +29,24 @@ include_guard(GLOBAL)
 # SOURCE (required)
 #   The source file that must not compile.
 #
-# EXPECT (required)
+# EXPECT (optional)
 #   A regular expression matched against the compiler output. The test
 #   passes only when the output matches, which confirms the failure is the
 #   intended static_assert, deleted overload, or constraint, and not an
 #   unrelated build error. Alternations such as
 #   "use of deleted function|call to deleted" cover compiler phrasings.
 #
+#   When omitted, the regex is read from SOURCE, which must then contain
+#   one or more lines of the form
+#
+#     // EXPECT: "<regex>"
+#
+#   so the expectation lives next to the ill-formed code it describes.
+#   Several lines are joined with "|", so a long alternation can be split
+#   one compiler's wording per line and stay inside a formatter's column
+#   limit. Configuration re-runs when that file changes. Passing EXPECT
+#   overrides the comment, for sources that cannot carry one.
+#
 # LINK_LIBRARIES (optional)
 #   Targets whose usage requirements the source is compiled with, typically
 #   the library under test. Nothing is ever linked.
@@ -93,10 +104,40 @@ function(beman_add_xfail_compile_test name)
             "beman_add_xfail_compile_test(${name}): SOURCE must be specified"
         )
     endif()
-    if(NOT BEMAN_XFAIL_EXPECT)
+    if(NOT DEFINED BEMAN_XFAIL_EXPECT)
+        file(
+            REAL_PATH "${BEMAN_XFAIL_SOURCE}"
+            _source_path
+            BASE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+        )
+        set_property(
+            DIRECTORY
+            APPEND
+            PROPERTY CMAKE_CONFIGURE_DEPENDS "${_source_path}"
+        )
+        file(STRINGS "${_source_path}" _expect_lines REGEX "^// EXPECT: \"")
+        if(NOT _expect_lines)
+            message(
+                FATAL_ERROR
+                "beman_add_xfail_compile_test(${name}): no '// EXPECT: \"<regex>\"' line in ${_source_path}; add one or pass EXPECT"
+            )
+        endif()
+        set(_alternatives)
+        foreach(_line IN LISTS _expect_lines)
+            string(
+                REGEX REPLACE "^// EXPECT: \"(.*)\"[ \t]*$"
+                "\\1"
+                _alternative
+                "${_line}"
+            )
+            list(APPEND _alternatives "${_alternative}")
+        endforeach()
+        list(JOIN _alternatives "|" BEMAN_XFAIL_EXPECT)
+    endif()
+    if("${BEMAN_XFAIL_EXPECT}" STREQUAL "")
         message(
             FATAL_ERROR
-            "beman_add_xfail_compile_test(${name}): EXPECT must be specified"
+            "beman_add_xfail_compile_test(${name}): EXPECT must not be empty"
         )
     endif()
     string(FIND "${BEMAN_XFAIL_EXPECT}" ";" _semicolon)
diff --git a/docs/plan/tests-overview.md b/docs/plan/tests-overview.md
index f6bd196..ccd8d4e 100644
--- a/docs/plan/tests-overview.md
+++ b/docs/plan/tests-overview.md
@@ -37,7 +37,7 @@ the failure is the intended constraint/mandate, not an unrelated build error.
 
 #### Source file format
 
-Every `_fail.cpp` must have these comment lines near the top:
+Every `_fail.test.cpp` must have these comment lines near the top:
 
 ```cpp
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -45,44 +45,54 @@ Every `_fail.cpp` must have these comment lines near the top:
 // EXPECT: "<regex that matches the compiler diagnostic>"
 ```
 
-The `EXPECT` string is the same regex passed to `add_fail_test()` in CMake.
-It should match:
+**The `EXPECT` line is the regex.** CMake reads it at configure time; there
+is no second copy to keep in step. It is a CMake regular expression and
+must not contain `;`. A file may carry several `EXPECT` lines; they are
+joined with `|`, so split a long alternation one compiler's wording per
+line rather than let clang-format reflow a line past column 119 (which
+would also merge it into the comment after it). The regex should match:
 - The `static_assert` message string for **mandates**
   (e.g. `"E must not be void"`)
-- `"delete"` for **deleted function** diagnostics
-- `"no matching function"` for **SFINAE / constraint** failures where no
-  overload is viable
-- `"no matching function|delete"` when either form is possible depending
-  on compiler
+- The `= delete("...")` message, or `"use of deleted function|call to
+  deleted|attempting to reference"` (gcc, clang, MSVC) for deleted
+  overloads without one
+- `"no matching function|no matching constructor|no overloaded function
+  could convert"` for **SFINAE / constraint** failures where no overload is
+  viable
+- An alternation of those when either form is possible depending on the
+  compiler. Every alternative must be a wording some supported compiler
+  actually produces; the test passes on the first match.
 
 #### CMakeLists pattern
 
-Use the `add_fail_test(name source reason)` macro, which registers the
-test with `PASS_REGULAR_EXPRESSION`:
+Register the file with `beman_add_xfail_compile_test()` from
+`cmake/beman-xfail-compile.cmake`:
 
 ```cmake
-add_fail_test(expected_ref_e_void_fail expected_ref_e_void_fail.cpp
-    "E must not be void"
+beman_add_xfail_compile_test(
+    expected_ref_e_void_fail
+    SOURCE expected_ref_e_void_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 ```
 
-The macro expands to:
-
-```cmake
-add_library(beman.expected.tests.<name> OBJECT)
-target_sources(beman.expected.tests.<name> PRIVATE <source>)
-target_link_libraries(beman.expected.tests.<name> PRIVATE beman::expected)
-set_target_properties(
-    beman.expected.tests.<name>
-    PROPERTIES EXCLUDE_FROM_ALL true EXCLUDE_FROM_DEFAULT_BUILD true
-)
-add_test(
-    NAME <name>
-    COMMAND ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}"
-            --target beman.expected.tests.<name> --config $<CONFIGURATION>
-)
-set_tests_properties(<name> PROPERTIES PASS_REGULAR_EXPRESSION "<reason>")
-```
+The function builds an OBJECT library `beman.expected.tests.<name>` that is
+excluded from the default build, and registers a ctest named `<name>` that
+runs `cmake/beman-xfail-compile-driver.cmake`. The driver does a nested
+build of just that target and passes only when the build fails **and** its
+output matches `EXPECT`. It reports the two ways of failing separately:
+
+- *compiled, but was expected to fail* — the constraint or mandate is not
+  firing;
+- *failed to compile, but not for the expected reason* — a typo in the
+  test, or a compiler whose wording the regex does not yet cover. The
+  build output is echoed; add the new wording as an alternative.
+
+Every test carries the label `xfail-compile` (`ctest -L xfail-compile`
+runs just this suite, `-LE` skips it) and a resource lock so `ctest -j`
+never runs two nested builds at once. `EXPECT <regex>` may be passed
+explicitly to override the comment; the header of the module documents
+the full interface.
 
 ### 4. Type-trait / static_assert tests
 
diff --git a/tests/beman/expected/CMakeLists.txt b/tests/beman/expected/CMakeLists.txt
index 38b7eca..2068d5e 100644
--- a/tests/beman/expected/CMakeLists.txt
+++ b/tests/beman/expected/CMakeLists.txt
@@ -156,19 +156,16 @@ beman_add_xfail_compile_test(
     unexpected_array_fail
     SOURCE unexpected_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an array type"
 )
 beman_add_xfail_compile_test(
     unexpected_cvref_fail
     SOURCE unexpected_cvref_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be cv-qualified"
 )
 beman_add_xfail_compile_test(
     unexpected_self_fail
     SOURCE unexpected_self_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be a specialization of unexpected"
 )
 
 # Step 3 — expected<T,E> ill-formed T/E [expected.object.general]
@@ -176,15 +173,12 @@ beman_add_xfail_compile_test(
     expected_t_ref_fail
     SOURCE expected_t_ref_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no default constructor|use of deleted function|call to deleted|attempting to reference"
 )
 # Note: expected_e_ref_fail removed — expected<int, int&> is now valid via expected<T,E&>
 beman_add_xfail_compile_test(
     expected_t_array_fail
     SOURCE expected_t_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be an array type"
 )
 
 # Step 3 — expected<T,E> emplace Mandates: nothrow_constructible_v<T,Args...>
@@ -192,7 +186,6 @@ beman_add_xfail_compile_test(
     expected_emplace_throwing_fail
     SOURCE expected_emplace_throwing_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "is_nothrow_constructible|no matching overloaded function found"
 )
 
 # Step 4 — expected<void,E> ill-formed E [expected.void.general]
@@ -202,7 +195,6 @@ beman_add_xfail_compile_test(
     expected_void_array_fail
     SOURCE expected_void_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an array type"
 )
 
 # Step 5 — monadic Mandates [expected.object.monadic]
@@ -210,25 +202,21 @@ beman_add_xfail_compile_test(
     and_then_wrong_error_type_fail
     SOURCE and_then_wrong_error_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same error_type"
 )
 beman_add_xfail_compile_test(
     and_then_not_expected_fail
     SOURCE and_then_not_expected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return a specialization of expected"
 )
 beman_add_xfail_compile_test(
     or_else_wrong_value_type_fail
     SOURCE or_else_wrong_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same value_type"
 )
 beman_add_xfail_compile_test(
     transform_error_ref_result_fail
     SOURCE transform_error_ref_result_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "G must be an object type"
 )
 
 # Step 6 — void monadic Mandates [expected.void.monadic]
@@ -236,13 +224,11 @@ beman_add_xfail_compile_test(
     void_and_then_wrong_error_type_fail
     SOURCE void_and_then_wrong_error_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same error_type"
 )
 beman_add_xfail_compile_test(
     void_or_else_wrong_value_type_fail
     SOURCE void_or_else_wrong_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same value_type"
 )
 
 # Fix 1 — constraint 23.6: value ctor blocked for T=bool, U=expected specialization
@@ -250,8 +236,6 @@ beman_add_xfail_compile_test(
     expected_bool_value_ctor_from_expected_fail
     SOURCE expected_bool_value_ctor_from_expected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no matching function|no matching constructor|no overloaded function could convert"
 )
 
 # Fix 4 — Mandates: T must not be a specialization of unexpected
@@ -259,7 +243,6 @@ beman_add_xfail_compile_test(
     expected_unexpected_value_type_fail
     SOURCE expected_unexpected_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be a specialization of unexpected"
 )
 
 # Step 7 — expected<T&, E> reference specialization: constructor constraints
@@ -267,22 +250,16 @@ beman_add_xfail_compile_test(
     expected_ref_temporary_fail
     SOURCE expected_ref_temporary_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_no_default_fail
     SOURCE expected_ref_no_default_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no default constructor|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_inplace_value_fail
     SOURCE expected_ref_inplace_value_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 8 — expected<T, E&> reference error: dangling prevention
@@ -290,15 +267,11 @@ beman_add_xfail_compile_test(
     expected_ref_e_temporary_error_fail
     SOURCE expected_ref_e_temporary_error_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_const_lvalue_fail
     SOURCE expected_ref_e_const_lvalue_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 8 — expected<T, E&>: no constructor or assignment from unexpected<G>
@@ -307,15 +280,11 @@ beman_add_xfail_compile_test(
     expected_ref_e_construct_from_unexpected_fail
     SOURCE expected_ref_e_construct_from_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_assign_unexpected_fail
     SOURCE expected_ref_e_assign_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
 )
 
 # Step 7/8 parity — expected<T&,E> or_else value_type mandate (added in Step 8 review)
@@ -323,7 +292,6 @@ beman_add_xfail_compile_test(
     expected_ref_or_else_wrong_value_type_fail
     SOURCE expected_ref_or_else_wrong_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same value_type"
 )
 
 # Step 9 — expected<T&, E&> dangling prevention and no-default constraint
@@ -331,22 +299,16 @@ beman_add_xfail_compile_test(
     expected_ref_both_temporary_val_fail
     SOURCE expected_ref_both_temporary_val_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted|no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_temporary_err_fail
     SOURCE expected_ref_both_temporary_err_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_no_default_fail
     SOURCE expected_ref_both_no_default_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no default constructor|use of deleted function|call to deleted|attempting to reference"
 )
 
 # Step 9 — expected<T&, E&>: no constructor or assignment from unexpected<G>
@@ -355,15 +317,11 @@ beman_add_xfail_compile_test(
     expected_ref_both_construct_from_unexpected_fail
     SOURCE expected_ref_both_construct_from_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_assign_unexpected_fail
     SOURCE expected_ref_both_assign_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator|attempting to reference"
 )
 
 # Step 9 — expected<T&, E&>: or_else value_type mandate
@@ -371,7 +329,6 @@ beman_add_xfail_compile_test(
     expected_ref_both_or_else_wrong_value_type_fail
     SOURCE expected_ref_both_or_else_wrong_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same value_type"
 )
 
 # Step 7 — expected<T&, E> Mandates: E constraints
@@ -379,25 +336,21 @@ beman_add_xfail_compile_test(
     expected_ref_e_ref_fail
     SOURCE expected_ref_e_ref_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an rvalue reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_void_fail
     SOURCE expected_ref_e_void_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be void"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_array_fail
     SOURCE expected_ref_e_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an array type"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_cv_fail
     SOURCE expected_ref_e_cv_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be cv-qualified"
 )
 
 # Step 7 — expected<T&, E> monadic mandates
@@ -405,13 +358,11 @@ beman_add_xfail_compile_test(
     expected_ref_and_then_wrong_error_type_fail
     SOURCE expected_ref_and_then_wrong_error_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same error_type"
 )
 beman_add_xfail_compile_test(
     expected_ref_transform_error_ref_result_fail
     SOURCE expected_ref_transform_error_ref_result_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "G must be an object type"
 )
 
 # Step 8 — expected<T, E&> Mandates: T and E type constraints
@@ -419,38 +370,31 @@ beman_add_xfail_compile_test(
     expected_ref_e_t_array_fail
     SOURCE expected_ref_e_t_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be an array type"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_e_array_fail
     SOURCE expected_ref_e_e_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an array type"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_t_inplace_fail
     SOURCE expected_ref_e_t_inplace_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be in_place_t"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_t_unexpect_fail
     SOURCE expected_ref_e_t_unexpect_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be unexpect_t"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_t_unexpected_fail
     SOURCE expected_ref_e_t_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be a specialization of unexpected"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_initializer_list_fail
     SOURCE expected_ref_e_initializer_list_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # Step 8 — expected<T, E&> monadic mandates
@@ -458,19 +402,16 @@ beman_add_xfail_compile_test(
     expected_ref_e_and_then_wrong_error_type_fail
     SOURCE expected_ref_e_and_then_wrong_error_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same error_type"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_or_else_wrong_value_type_fail
     SOURCE expected_ref_e_or_else_wrong_value_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same value_type"
 )
 beman_add_xfail_compile_test(
     expected_ref_e_transform_error_ref_result_fail
     SOURCE expected_ref_e_transform_error_ref_result_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "G must be an object type"
 )
 
 # Step 9 — expected<T&, E&> Mandates: T and E type constraints
@@ -478,45 +419,36 @@ beman_add_xfail_compile_test(
     expected_ref_both_t_array_fail
     SOURCE expected_ref_both_t_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be an array type"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_e_array_fail
     SOURCE expected_ref_both_e_array_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "E must not be an array type"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_t_inplace_fail
     SOURCE expected_ref_both_t_inplace_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be in_place_t"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_t_unexpect_fail
     SOURCE expected_ref_both_t_unexpect_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be unexpect_t"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_t_unexpected_fail
     SOURCE expected_ref_both_t_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "T must not be a specialization of unexpected"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_inplace_value_fail
     SOURCE expected_ref_both_inplace_value_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_initializer_list_fail
     SOURCE expected_ref_both_initializer_list_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # Step 9 — expected<T&, E&> monadic mandates
@@ -524,13 +456,11 @@ beman_add_xfail_compile_test(
     expected_ref_both_and_then_wrong_error_type_fail
     SOURCE expected_ref_both_and_then_wrong_error_type_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "F must return expected with the same error_type"
 )
 beman_add_xfail_compile_test(
     expected_ref_both_transform_error_ref_result_fail
     SOURCE expected_ref_both_transform_error_ref_result_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT "G must be an object type"
 )
 
 # Step 10 — expected<void, E&> dangling prevention and no value_or
@@ -538,43 +468,31 @@ beman_add_xfail_compile_test(
     expected_void_ref_e_temporary_fail
     SOURCE expected_void_ref_e_temporary_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_void_ref_e_const_lvalue_fail
     SOURCE expected_void_ref_e_const_lvalue_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_void_ref_e_no_value_or_fail
     SOURCE expected_void_ref_e_no_value_or_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no value_or for void|use of deleted function|call to deleted|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_void_ref_e_construct_from_unexpected_fail
     SOURCE expected_void_ref_e_construct_from_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_void_ref_e_assign_unexpected_fail
     SOURCE expected_void_ref_e_assign_unexpected_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "no assignment from unexpected|use of deleted function|call to deleted|invokes a deleted function|selected deleted operator|attempting to reference"
 )
 beman_add_xfail_compile_test(
     expected_void_ref_e_initializer_list_fail
     SOURCE expected_void_ref_e_initializer_list_fail.test.cpp
     LINK_LIBRARIES beman::expected
-    EXPECT
-        "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 )
 
 # =============================================================================
diff --git a/tests/beman/expected/expected_bool_value_ctor_from_expected_fail.test.cpp b/tests/beman/expected/expected_bool_value_ctor_from_expected_fail.test.cpp
index de37c28..1b35550 100644
--- a/tests/beman/expected/expected_bool_value_ctor_from_expected_fail.test.cpp
+++ b/tests/beman/expected/expected_bool_value_ctor_from_expected_fail.test.cpp
@@ -3,7 +3,7 @@
 //
 // NEGATIVE: expected<bool, E> cannot be constructed from expected<U, G> via
 // the value ctor when the converting ctor is not viable.
-// EXPECT: "no matching function"
+// EXPECT: "no matching function|no matching constructor|no overloaded function could convert"
 //
 // Constraint 23.6: if T is cv bool, remove_cvref_t<U> must not be a
 // specialization of expected. This blocks the value ctor from selecting
diff --git a/tests/beman/expected/expected_emplace_throwing_fail.test.cpp b/tests/beman/expected/expected_emplace_throwing_fail.test.cpp
index 75f2653..920fd45 100644
--- a/tests/beman/expected/expected_emplace_throwing_fail.test.cpp
+++ b/tests/beman/expected/expected_emplace_throwing_fail.test.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: emplace requires nothrow_constructible_v<T, Args...>
-// EXPECT: "is_nothrow_constructible"
+// EXPECT: "is_nothrow_constructible|no matching overloaded function found"
 #include <beman/expected/expected.hpp>
 
 struct ThrowingCtor {
diff --git a/tests/beman/expected/expected_ref_both_assign_unexpected_fail.test.cpp b/tests/beman/expected/expected_ref_both_assign_unexpected_fail.test.cpp
index 2dd24f5..4478be2 100644
--- a/tests/beman/expected/expected_ref_both_assign_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_assign_unexpected_fail.test.cpp
@@ -3,7 +3,8 @@
 // No operator=(unexpected<G>...) exists: binding E& to temporary unexpected
 // storage would create a dangling reference. Copy-assign from another
 // expected<T&, E&>(unexpect, new_err) to rebind the error reference safely.
-// EXPECT: "no matching function"
+// EXPECT: "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator"
+// EXPECT: "attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_ref_both_construct_from_unexpected_fail.test.cpp b/tests/beman/expected/expected_ref_both_construct_from_unexpected_fail.test.cpp
index 81c057a..98c483b 100644
--- a/tests/beman/expected/expected_ref_both_construct_from_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_construct_from_unexpected_fail.test.cpp
@@ -3,7 +3,8 @@
 // A value-typed unexpected<G> stores G by value; binding E& to it would create a
 // dangling reference when the unexpected object is destroyed. Construction from a
 // reference-typed unexpected<G&> (which holds an external object) is allowed.
-// EXPECT: "no matching function"
+// EXPECT: "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function"
+// EXPECT: "attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_ref_both_initializer_list_fail.test.cpp b/tests/beman/expected/expected_ref_both_initializer_list_fail.test.cpp
index 270479a..96c1e21 100644
--- a/tests/beman/expected/expected_ref_both_initializer_list_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_initializer_list_fail.test.cpp
@@ -1,4 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// NEGATIVE: expected<T&, E&> initializer-list error construction: E& cannot bind to the list
+// EXPECT: "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_ref_both_inplace_value_fail.test.cpp b/tests/beman/expected/expected_ref_both_inplace_value_fail.test.cpp
index 9a5f69f..a01011f 100644
--- a/tests/beman/expected/expected_ref_both_inplace_value_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_inplace_value_fail.test.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: expected<T&, E&> has no in_place_t value constructor
-// EXPECT: "no matching function"
+// EXPECT: "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 #include <utility>
 void test() {
diff --git a/tests/beman/expected/expected_ref_both_no_default_fail.test.cpp b/tests/beman/expected/expected_ref_both_no_default_fail.test.cpp
index 8faf5f6..6e182da 100644
--- a/tests/beman/expected/expected_ref_both_no_default_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_no_default_fail.test.cpp
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// Negative compile test: expected<T&, E&> has no default constructor.
+// NEGATIVE: expected<T&, E&> has no default constructor
+// EXPECT: "no default constructor|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_ref_both_temporary_err_fail.test.cpp b/tests/beman/expected/expected_ref_both_temporary_err_fail.test.cpp
index 1e7bc57..95b4f8f 100644
--- a/tests/beman/expected/expected_ref_both_temporary_err_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_temporary_err_fail.test.cpp
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// Negative compile test: binding a temporary to E& in expected<T&, E&> must fail.
+// NEGATIVE: binding a temporary to E& in expected<T&, E&> must fail
+// EXPECT: "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_ref_both_temporary_val_fail.test.cpp b/tests/beman/expected/expected_ref_both_temporary_val_fail.test.cpp
index 06da155..9e90a31 100644
--- a/tests/beman/expected/expected_ref_both_temporary_val_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_both_temporary_val_fail.test.cpp
@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// Negative compile test: binding a temporary to T& in expected<T&, E&> must fail.
+// NEGATIVE: binding a temporary to T& in expected<T&, E&> must fail
+// EXPECT: "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted"
+// EXPECT: "no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_ref_e_assign_unexpected_fail.test.cpp b/tests/beman/expected/expected_ref_e_assign_unexpected_fail.test.cpp
index 71593af..2f2d76d 100644
--- a/tests/beman/expected/expected_ref_e_assign_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_e_assign_unexpected_fail.test.cpp
@@ -3,7 +3,8 @@
 // No operator=(unexpected<G>...) exists: binding E& to temporary unexpected
 // storage would create a dangling reference. Use copy-assign from another
 // expected<T, E&> to rebind the error reference safely.
-// EXPECT: "no matching function"
+// EXPECT: "no assignment from unexpected|use of deleted function|call to deleted|selected deleted operator"
+// EXPECT: "attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_ref_e_const_lvalue_fail.test.cpp b/tests/beman/expected/expected_ref_e_const_lvalue_fail.test.cpp
index ca89145..a1c8f7e 100644
--- a/tests/beman/expected/expected_ref_e_const_lvalue_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_e_const_lvalue_fail.test.cpp
@@ -1,7 +1,7 @@
 // tests/beman/expected/expected_ref_e_const_lvalue_fail.cpp           -*-C++-*-
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: cannot bind a const lvalue to non-const E& — language-level constraint
-// EXPECT: "no matching function|cannot bind"
+// EXPECT: "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     const int err = 5;
diff --git a/tests/beman/expected/expected_ref_e_construct_from_unexpected_fail.test.cpp b/tests/beman/expected/expected_ref_e_construct_from_unexpected_fail.test.cpp
index a8fff21..af0a8da 100644
--- a/tests/beman/expected/expected_ref_e_construct_from_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_e_construct_from_unexpected_fail.test.cpp
@@ -3,7 +3,8 @@
 // A value-typed unexpected<G> stores G by value; binding E& to it would create a
 // dangling reference when the unexpected object is destroyed. Construction from a
 // reference-typed unexpected<G&> (which holds an external object) is allowed.
-// EXPECT: "no matching function"
+// EXPECT: "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function"
+// EXPECT: "attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_ref_e_initializer_list_fail.test.cpp b/tests/beman/expected/expected_ref_e_initializer_list_fail.test.cpp
index 3c16c15..f9707a4 100644
--- a/tests/beman/expected/expected_ref_e_initializer_list_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_e_initializer_list_fail.test.cpp
@@ -1,4 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// NEGATIVE: expected<T, E&> initializer-list error construction: E& cannot bind to the list
+// EXPECT: "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_ref_e_temporary_error_fail.test.cpp b/tests/beman/expected/expected_ref_e_temporary_error_fail.test.cpp
index 8b95b43..170cfb7 100644
--- a/tests/beman/expected/expected_ref_e_temporary_error_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_e_temporary_error_fail.test.cpp
@@ -1,7 +1,7 @@
 // tests/beman/expected/expected_ref_e_temporary_error_fail.cpp        -*-C++-*-
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: cannot bind a temporary (rvalue) to E& — dangling prevention
-// EXPECT: "delete|no matching function"
+// EXPECT: "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     // 42 is a temporary — expected<int, int&> must refuse to bind E& to it
diff --git a/tests/beman/expected/expected_ref_inplace_value_fail.test.cpp b/tests/beman/expected/expected_ref_inplace_value_fail.test.cpp
index 0c4d8d0..1e3f079 100644
--- a/tests/beman/expected/expected_ref_inplace_value_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_inplace_value_fail.test.cpp
@@ -1,7 +1,7 @@
 // tests/beman/expected/expected_ref_inplace_value_fail.cpp           -*-C++-*-
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: expected<T&, E> has no in_place_t value constructor
-// EXPECT: "no matching function"
+// EXPECT: "no in_place value constructor|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     int                                  x = 5;
diff --git a/tests/beman/expected/expected_ref_no_default_fail.test.cpp b/tests/beman/expected/expected_ref_no_default_fail.test.cpp
index 78c0154..88f3f22 100644
--- a/tests/beman/expected/expected_ref_no_default_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_no_default_fail.test.cpp
@@ -1,7 +1,7 @@
 // tests/beman/expected/expected_ref_no_default_fail.cpp              -*-C++-*-
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: expected<T&, E> has no default constructor
-// EXPECT: "delete"
+// EXPECT: "no default constructor|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     beman::expected::expected<int&, int> e; // must not compile
diff --git a/tests/beman/expected/expected_ref_temporary_fail.test.cpp b/tests/beman/expected/expected_ref_temporary_fail.test.cpp
index 907053d..c2749e4 100644
--- a/tests/beman/expected/expected_ref_temporary_fail.test.cpp
+++ b/tests/beman/expected/expected_ref_temporary_fail.test.cpp
@@ -1,7 +1,8 @@
 // tests/beman/expected/expected_ref_temporary_fail.cpp               -*-C++-*-
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: constructing expected<int&, E> from a temporary must not compile
-// EXPECT: "no matching function|delete"
+// EXPECT: "binding a temporary to T& creates a dangling reference|use of deleted function|call to deleted"
+// EXPECT: "no matching function|no matching constructor|no overloaded function could convert|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     beman::expected::expected<int&, int> e(42); // 42 is a temporary
diff --git a/tests/beman/expected/expected_t_ref_fail.test.cpp b/tests/beman/expected/expected_t_ref_fail.test.cpp
index d221aff..53635b5 100644
--- a/tests/beman/expected/expected_t_ref_fail.test.cpp
+++ b/tests/beman/expected/expected_t_ref_fail.test.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: expected<int&, int> now matches the reference specialization which has no default ctor
-// EXPECT: "delete"
+// EXPECT: "no default constructor|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 
 beman::expected::expected<int&, int> e; // must not compile
diff --git a/tests/beman/expected/expected_void_ref_e_assign_unexpected_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_assign_unexpected_fail.test.cpp
index 0ed7a19..cdfabde 100644
--- a/tests/beman/expected/expected_void_ref_e_assign_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_assign_unexpected_fail.test.cpp
@@ -2,7 +2,8 @@
 // NEGATIVE: expected<void, E&> cannot be assigned from unexpected<G>.
 // No operator=(unexpected<G>...) exists: binding E& to temporary unexpected
 // storage would create a dangling reference.
-// EXPECT: "no matching function"
+// EXPECT: "no assignment from unexpected|use of deleted function|call to deleted|invokes a deleted function"
+// EXPECT: "selected deleted operator|attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_void_ref_e_const_lvalue_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_const_lvalue_fail.test.cpp
index 5e4b652..72dbb27 100644
--- a/tests/beman/expected/expected_void_ref_e_const_lvalue_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_const_lvalue_fail.test.cpp
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: cannot bind const lvalue to non-const E&
+// EXPECT: "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     const int                             err = 5;
diff --git a/tests/beman/expected/expected_void_ref_e_construct_from_unexpected_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_construct_from_unexpected_fail.test.cpp
index b37eea7..f4242ea 100644
--- a/tests/beman/expected/expected_void_ref_e_construct_from_unexpected_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_construct_from_unexpected_fail.test.cpp
@@ -3,7 +3,8 @@
 // A value-typed unexpected<G> stores G by value; binding E& to it would create a
 // dangling reference when the unexpected object is destroyed. Construction from a
 // reference-typed unexpected<G&> (which holds an external object) is allowed.
-// EXPECT: "no matching function"
+// EXPECT: "no constructor from unexpected|use of deleted function|call to deleted|invokes a deleted function"
+// EXPECT: "attempting to reference"
 #include <beman/expected/expected.hpp>
 using namespace beman::expected;
 void test() {
diff --git a/tests/beman/expected/expected_void_ref_e_initializer_list_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_initializer_list_fail.test.cpp
index 11e072a..57070f1 100644
--- a/tests/beman/expected/expected_void_ref_e_initializer_list_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_initializer_list_fail.test.cpp
@@ -1,4 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// NEGATIVE: expected<void, E&> initializer-list error construction: E& cannot bind to the list
+// EXPECT: "initializer-list error construction cannot bind a reference|use of deleted function|call to deleted"
 #include <beman/expected/expected.hpp>
 
 using namespace beman::expected;
diff --git a/tests/beman/expected/expected_void_ref_e_no_value_or_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_no_value_or_fail.test.cpp
index d4ff123..82d85c5 100644
--- a/tests/beman/expected/expected_void_ref_e_no_value_or_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_no_value_or_fail.test.cpp
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: expected<void, E&> has no value_or member
+// EXPECT: "no value_or for void|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() {
     beman::expected::expected<void, int&> e;
diff --git a/tests/beman/expected/expected_void_ref_e_temporary_fail.test.cpp b/tests/beman/expected/expected_void_ref_e_temporary_fail.test.cpp
index 3e2619b..5a69991 100644
--- a/tests/beman/expected/expected_void_ref_e_temporary_fail.test.cpp
+++ b/tests/beman/expected/expected_void_ref_e_temporary_fail.test.cpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 // NEGATIVE: cannot bind temporary to E& — dangling prevention
+// EXPECT: "cannot bind to non-const E&|use of deleted function|call to deleted|attempting to reference"
 #include <beman/expected/expected.hpp>
 void test() { beman::expected::expected<void, int&> e(beman::expected::unexpect, 42); }

From 7fe1a3f5e45edf609da9a0a6fcf7261ae496df0c Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 15:07:11 -0400
Subject: [PATCH 7/9] Record stage expect-in-source as done in the extraction
 plan

---
 docs/plan/extract-xfail-compile.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
index d23aeb8..fe7f6fa 100644
--- a/docs/plan/extract-xfail-compile.md
+++ b/docs/plan/extract-xfail-compile.md
@@ -202,6 +202,13 @@ module read the comment when `EXPECT` is omitted.
 Acceptance: 59/59 of the `_fail.test.cpp` files carry an EXPECT comment;
 removing one makes configure fail with a message naming the file.
 
+**Status:** DONE 2026-10-19. Log: a source may carry several `EXPECT`
+lines, joined with `|` by the module, because clang-format (column limit
+119, `ReflowComments: true`) rewraps a longer comment line and merges it
+into the comment after it. Eight files use this. Every regex ctest
+receives was checked byte-identical to the one the call site used to
+pass.
+
 ### Stage 4 — [infra-pr](#infra-pr)
 
 In `~/src/beman-infra/main`: add `upstream` → `bemanproject/infra`, branch,
@@ -304,6 +311,9 @@ cannot annotate (vendored sources) and for one-off overrides.
 **Log:** 2026-10-19 decided. Reconciliation goes toward the CMake regex,
 not the comment, because the CMake regex is the one proven on gcc, clang,
 and MSVC.
+2026-10-19: the comment is one *or more* `EXPECT` lines, OR-ed together.
+A single line was the plan, but clang-format reflows comments past column
+119, so a long alternation has to be split at an alternative boundary.
 
 ### concurrent-nested-builds
 

From e84b7eef2758772d55cfff7e54330967e825edc6 Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 15:42:45 -0400
Subject: [PATCH 8/9] Record PR #108 and the infra worktree in the extraction
 plan

---
 docs/plan/extract-xfail-compile.md | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
index fe7f6fa..975be33 100644
--- a/docs/plan/extract-xfail-compile.md
+++ b/docs/plan/extract-xfail-compile.md
@@ -97,8 +97,8 @@ own modules; consumers are the test.
 (pinned in `infra/.beman_submodule` to `749c558`), so edits made under
 `infra/` here are overwritten by the next `beman-submodule update`. The
 module has to go upstream through a fork of `bemanproject/infra`
-(`~/src/beman-infra/main`, `origin` = `steve-downey/infra`; it needs an
-`upstream` remote added for the PR).
+(`~/src/beman-infra/main`, `origin` = `steve-downey/infra`, `upstream` =
+`bemanproject/infra`; worktrees live beside `main`, one per branch).
 
 ## Proposed interface
 
@@ -211,13 +211,21 @@ pass.
 
 ### Stage 4 — [infra-pr](#infra-pr)
 
-In `~/src/beman-infra/main`: add `upstream` → `bemanproject/infra`, branch,
-copy the module and driver into `cmake/`, add a README section modelled on
+From `~/src/beman-infra/main`: branch from `upstream/main` into a sibling
+worktree, copy the module and driver into `cmake/`, add a README section modelled on
 the `beman_install_library` one (usage snippet, argument list, what the
 test does, the label and lock, the EXPECT-from-source rule), run
 pre-commit, open the PR against `bemanproject/infra`. Point at this repo's
 59 uses and optional's one as the implementation experience.
 
+**Status:** IN PROGRESS 2026-10-19. Log: stages 1–3 are
+[bemanproject/expected#108](https://github.com/bemanproject/expected/pull/108).
+Worktree `~/src/beman-infra/xfail-compile` on branch `xfail-compile` from
+`upstream/main` (749c558) holds the module, driver, and README section as
+one commit; infra's pre-commit (gersemi 0.27.2) passes. Fork `main`,
+`upstream/main`, and the copy vendored here were all at 749c558, so there
+was no drift to fix. Not yet pushed; the PR is the next step.
+
 ### Stage 5 — [adopt-pin](#adopt-pin)
 
 After the infra PR merges: `beman-submodule update --remote` here, delete

From c7e9dc646ea7d844389eba3a2bfd4d60f4452c36 Mon Sep 17 00:00:00 2001
From: Steve Downey <sdowney@gmail.com>
Date: Mon, 19 Oct 2026 16:01:53 -0400
Subject: [PATCH 9/9] Record the draft infra PR in the extraction plan

---
 docs/plan/extract-xfail-compile.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
index 975be33..08a020c 100644
--- a/docs/plan/extract-xfail-compile.md
+++ b/docs/plan/extract-xfail-compile.md
@@ -224,7 +224,10 @@ Worktree `~/src/beman-infra/xfail-compile` on branch `xfail-compile` from
 `upstream/main` (749c558) holds the module, driver, and README section as
 one commit; infra's pre-commit (gersemi 0.27.2) passes. Fork `main`,
 `upstream/main`, and the copy vendored here were all at 749c558, so there
-was no drift to fix. Not yet pushed; the PR is the next step.
+was no drift to fix.
+2026-10-19: opened as draft
+[bemanproject/infra#67](https://github.com/bemanproject/infra/pull/67),
+asking reviewers about the name, a self-test, and MSVC coverage.
 
 ### Stage 5 — [adopt-pin](#adopt-pin)