fix(bench): the harness could not drive the xmake arm it had just built

两处 harness 与描述之间的错配。都是「手工跑得通、harness 跑不通」——
这类差异最容易被读成「引擎不行」。

**1. `--buildfiles` 没转绝对路径。** 每个引擎都以该目录为 cwd 启动,而 xmake 又
把同一个路径当 `-P` 收下,于是相对路径解析两次:

    --buildfiles bench/projects/xlings
      → bench/projects/xlings/bench/projects/xlings
    error: project not found!

从仓库根手工跑同一条命令是好的 —— 那里没有可供翻倍的前缀。和这套件已经修过一次
的 `--buildir` 翻倍是同一个形状,所以修在解析处一次,而不是每个适配器里各修一遍。

**2. payload 驱动经 `CXX` 传给 xmake 是错的机制。** 真实工程的描述把 payload
定义成一个 xmake **工具链**(编译器 + 它的 `-B<binutils>`/`--sysroot`,见
../common/xmake/payload.lua);只设 `CXX` 等于把编译器给了 xrepo 而**不给那些
flag**,于是每个依赖包都用它构建并失败:

    => install cmdline 0.0.2 .. failed
    => install mbedtls v3.6.7 .. failed
    => install ftxui v6.1.9 .. failed

而 `xmake f --toolchain=mcpp-gcc` 手工跑是成功的,因为工具链把两半一起给了。
生成的 fixture 没有这个定义(bench.fixture.buildfiles 把 flag 内联写进描述),
所以它仍走 CXX —— 两种情况按「描述是否在树之外」区分。fixture 已回归验证未受影响。

Author: speak-agent

bench/src/engines/xmake.cppm

@@ -6,9 +6,18 @@ import bench.protocol;
 import bench.spec;
 import bench.platform;
 import bench.engines.engine;
+import bench.toolchain;
 
 namespace bench::engines {
 
+// The toolchain name ../common/xmake/payload.lua defines for a payload driver.
+// Empty when the request is not a payload one (a bare `gcc`/`clang`/a path), in
+// which case there is nothing pinned to name.
+inline std::string payload_toolchain(std::string_view compiler) {
+    if (!compiler.starts_with("payload:")) return {};
+    return toolchain::resolves_to_clang(compiler) ? "mcpp-clang" : "mcpp-gcc";
+}
+
 class XmakeEngine : public Engine {
 public:
     std::string_view name() const override { return "xmake"; }
@@ -30,8 +39,33 @@ public:
             "-m", job.profile == "debug" ? "debug" : "release",
             "-o", job.build_dir.string(),
         };
-        if (job.compiler == "clang") argv.push_back("--toolchain=llvm");
+        // ── How the payload driver is pinned, and why it is not always CXX ──
+        //
+        // A real project's description (bench/projects/*/xmake.lua) DEFINES the
+        // payload as an xmake toolchain — compiler and its `-B<binutils>` /
+        // `--sysroot` flags together — in ../common/xmake/payload.lua. Naming
+        // that toolchain is the only way to get both halves.
         //
+        // Setting CXX instead hands xrepo a compiler WITHOUT those flags, and
+        // xmake then builds every dependency package with it. They fail:
+        //     => install cmdline 0.0.2 .. failed
+        //     => install mbedtls v3.6.7 .. failed
+        //     => install ftxui v6.1.9 .. failed
+        // — while the identical `xmake f --toolchain=mcpp-gcc` run by hand
+        // succeeds, because there the toolchain carries the flags.
+        //
+        // The generated fixture has no such definition (bench.fixture.buildfiles
+        // writes the payload flags inline), so it still takes CXX. The two cases
+        // are told apart by whether the description lives beside the tree.
+        const bool own_description = !job.buildfile_dir.empty() &&
+                                     job.buildfile_dir != job.project_dir;
+        if (own_description) {
+            if (const auto tc = payload_toolchain(job.compiler); !tc.empty()) {
+                argv.push_back("--toolchain=" + tc);
+                return platform::run(argv, job.buildfile_dir, job.log_path, job.timeout_s);
+            }
+        }
+        if (job.compiler == "clang") argv.push_back("--toolchain=llvm");
         // The driver is pinned through CXX so every engine compiles with the
         // SAME binary; without it xmake resolves whatever `g++` means on this
         // host, and the comparison silently becomes compiler-vs-compiler.

bench/src/main.cpp

@@ -189,7 +189,23 @@ std::expected<Options, std::string> parse(int argc, char** argv) {
         else if (a == "--list")      { o.list = true; }
         else if (a == "--analyze")   { auto v = value(a); if (!v) return std::unexpected(v.error()); o.analyze = *v; }
         else if (a == "--project")   { auto v = value(a); if (!v) return std::unexpected(v.error()); o.project = *v; }
-        else if (a == "--buildfiles"){ auto v = value(a); if (!v) return std::unexpected(v.error()); o.buildfiles = *v; }
+        // ABSOLUTE, resolved against the cwd the harness was STARTED in.
+        //
+        // Every engine is spawned with its cwd set to this directory, and xmake
+        // is then handed it again as `-P`. A relative path therefore resolves
+        // twice: `--buildfiles bench/projects/xlings` became
+        // `bench/projects/xlings/bench/projects/xlings` and the whole arm failed
+        // with `error: project not found!` — while the identical command run by
+        // hand from the repository root worked, because there the doubling had
+        // nothing to double against. Same shape as the `--buildir` doubling this
+        // suite already fixed once; the fix belongs here, once, rather than in
+        // each adapter.
+        else if (a == "--buildfiles"){
+            auto v = value(a); if (!v) return std::unexpected(v.error());
+            std::error_code ec;
+            auto abs = std::filesystem::absolute(*v, ec);
+            o.buildfiles = ec ? std::filesystem::path(*v) : abs;
+        }
         else if (a == "--hub")       { auto v = value(a); if (!v) return std::unexpected(v.error()); o.hub  = *v; }
         else if (a == "--leaf")      { auto v = value(a); if (!v) return std::unexpected(v.error()); o.leaf = *v; }
         else if (a == "--body")      { auto v = value(a); if (!v) return std::unexpected(v.error()); o.body = *v; }