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
new file mode 100644
index 0000000..4cc4d65
--- /dev/null
+++ b/cmake/beman-xfail-compile.cmake
@@ -0,0 +1,186 @@
+# 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 (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.
+#
+# 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, 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 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)
+    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 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 not be empty"
+        )
+    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()
+
+    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} -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
+            LABELS "xfail-compile;${BEMAN_XFAIL_LABELS}"
+            RESOURCE_LOCK beman-xfail-compile-build-tree
+    )
+endfunction()
diff --git a/docs/plan/extract-xfail-compile.md b/docs/plan/extract-xfail-compile.md
new file mode 100644
index 0000000..08a020c
--- /dev/null
+++ b/docs/plan/extract-xfail-compile.md
@@ -0,0 +1,406 @@
+# 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`, `upstream` =
+`bemanproject/infra`; worktrees live beside `main`, one per branch).
+
+## 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.
+
+**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
+`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.
+
+**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
+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.
+
+**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)
+
+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.
+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)
+
+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.
+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
+
+**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.
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 21250ec..2068d5e 100644
--- a/tests/beman/expected/CMakeLists.txt
+++ b/tests/beman/expected/CMakeLists.txt
@@ -145,284 +145,354 @@ 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
 )
-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
 )
-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
 )
 
 # 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
 )
 # 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
 )
 
 # 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
 )
 
 # 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
 )
 
 # 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"
+beman_add_xfail_compile_test(
+    and_then_wrong_error_type_fail
+    SOURCE and_then_wrong_error_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-add_fail_test(and_then_not_expected_fail        and_then_not_expected_fail.test.cpp
-    "F must return a specialization of expected"
+beman_add_xfail_compile_test(
+    and_then_not_expected_fail
+    SOURCE and_then_not_expected_fail.test.cpp
+    LINK_LIBRARIES beman::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"
+beman_add_xfail_compile_test(
+    or_else_wrong_value_type_fail
+    SOURCE or_else_wrong_value_type_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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(
+    transform_error_ref_result_fail
+    SOURCE transform_error_ref_result_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
 
 # 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
 )
 
 # 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
 )
 
 # 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"
+beman_add_xfail_compile_test(
+    expected_ref_temporary_fail
+    SOURCE expected_ref_temporary_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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"
+beman_add_xfail_compile_test(
+    expected_ref_no_default_fail
+    SOURCE expected_ref_no_default_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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_inplace_value_fail
+    SOURCE expected_ref_inplace_value_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
 
 # 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
 )
-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
 )
 
 # 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
 )
 
 # 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"
+beman_add_xfail_compile_test(
+    expected_ref_both_temporary_val_fail
+    SOURCE expected_ref_both_temporary_val_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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"
+beman_add_xfail_compile_test(
+    expected_ref_both_temporary_err_fail
+    SOURCE expected_ref_both_temporary_err_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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_no_default_fail
+    SOURCE expected_ref_both_no_default_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
 
 # 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
 )
 
 # 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"
+beman_add_xfail_compile_test(
+    expected_ref_e_ref_fail
+    SOURCE expected_ref_e_ref_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-add_fail_test(expected_ref_e_void_fail  expected_ref_e_void_fail.test.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
 )
-add_fail_test(expected_ref_e_array_fail expected_ref_e_array_fail.test.cpp
-    "E must not be an array type"
+beman_add_xfail_compile_test(
+    expected_ref_e_array_fail
+    SOURCE expected_ref_e_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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_cv_fail
+    SOURCE expected_ref_e_cv_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
 
 # 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"
+beman_add_xfail_compile_test(
+    expected_ref_e_t_array_fail
+    SOURCE expected_ref_e_t_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-add_fail_test(expected_ref_e_e_array_fail
-    expected_ref_e_e_array_fail.test.cpp
-    "E 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
 )
-add_fail_test(expected_ref_e_t_inplace_fail
-    expected_ref_e_t_inplace_fail.test.cpp
-    "T must not be in_place_t"
+beman_add_xfail_compile_test(
+    expected_ref_e_t_inplace_fail
+    SOURCE expected_ref_e_t_inplace_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-add_fail_test(expected_ref_e_t_unexpect_fail
-    expected_ref_e_t_unexpect_fail.test.cpp
-    "T must not be unexpect_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
 )
-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"
+beman_add_xfail_compile_test(
+    expected_ref_e_t_unexpected_fail
+    SOURCE expected_ref_e_t_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
-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_initializer_list_fail
+    SOURCE expected_ref_e_initializer_list_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
-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
 )
 
 # 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
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_e_array_fail
+    SOURCE expected_ref_both_e_array_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_inplace_fail
+    SOURCE expected_ref_both_t_inplace_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_unexpect_fail
+    SOURCE expected_ref_both_t_unexpect_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_t_unexpected_fail
+    SOURCE expected_ref_both_t_unexpected_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_inplace_value_fail
+    SOURCE expected_ref_both_inplace_value_fail.test.cpp
+    LINK_LIBRARIES beman::expected
+)
+beman_add_xfail_compile_test(
+    expected_ref_both_initializer_list_fail
+    SOURCE expected_ref_both_initializer_list_fail.test.cpp
+    LINK_LIBRARIES beman::expected
 )
 
 # 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
 )
-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
 )
 
 # 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
+)
+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
+)
+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
+)
+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
+)
+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
+)
+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
 )
 
 # =============================================================================
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); }