run/test: look the runner up by the canonical triple — the driver's spelling matched on Linux and never on macOS (measured on CI)

Author: speak-agent

.agents/docs/2026-09-02-runner-beyond-baremetal-design.md

@@ -298,10 +298,18 @@ For the resolved target, in order:
 
 The per-triple key is already the scoping mechanism for "this runner belongs to
 that cross target": a runner written under `[target.aarch64-linux-musl]` is not
-found when the host target is resolved, because the lookup is
-`targetOverrides.find(ctx.tc.targetTriple)` and the key is stored canonicalised
-(`toml.cppm:1825-1830, :1960`). No new key is needed to express applicability
-along the target axis.
+found when the host target is resolved, because the key is stored canonicalised
+(`toml.cppm:1825-1830, :1960`) and looked up by the resolved target. No new key
+is needed to express applicability along the target axis.
+
+The lookup key is the canonical spelling, `triple::parse(tc.targetTriple)->str()`,
+which is the output directory's name and the key every other
+`[target.<triple>]` reader in `prepare.cppm` resolves. The draft looked up
+`tc.targetTriple` as the driver reported it; on a Linux host that is the
+canonical spelling and on macOS it is `arm64-apple-darwin24.6.0`, so
+`[target.aarch64-macos].runner` matched on Linux hosts and never on macOS
+(measured on PR #545's macOS e2e shard, 2026-09-02). The raw spelling stays as
+a fallback for a triple the parser does not know.
 
 What the key cannot express is the host axis, and this is the limit D3 and D4
 respond to: the same triple is foreign on one host and native on another, and

src/build/execute.cppm

@@ -472,9 +472,25 @@ RunnerChoice choose_runner(const BuildContext& ctx, bool noRunner = false) {
     // for `-bios none -semihosting` while debugging, and — on a hosted cross
     // triple — for naming the user-mode emulator at all.
     c.tmpl = ctx.manifest.buildConfig.runner;
-    if (auto it = ctx.manifest.targetOverrides.find(ctx.tc.targetTriple);
-        it != ctx.manifest.targetOverrides.end() && !it->second.runner.empty()) {
-        c.tmpl = it->second.runner;
+    // The manifest key is the CANONICAL spelling — `aarch64-macos`, the name
+    // of the output directory and the key every other `[target.<triple>]`
+    // reader uses (prepare.cppm resolves overrides by `t.str()`). The
+    // toolchain's own `targetTriple` is what the driver reported, which on a
+    // Linux host happens to be the canonical spelling and on macOS is
+    // `arm64-apple-darwin24.6.0`. Looking up the raw spelling alone matched on
+    // Linux and never on macOS (measured on CI, 2026-09-02); the raw form is
+    // kept as a fallback for a triple the parser does not know.
+    auto lookup = [&](std::string_view key) {
+        auto it = ctx.manifest.targetOverrides.find(std::string(key));
+        return it != ctx.manifest.targetOverrides.end() && !it->second.runner.empty()
+             ? &it->second : nullptr;
+    };
+    const mcpp::manifest::TargetEntry* entry = nullptr;
+    if (auto ft = mcpp::toolchain::triple::parse(ctx.tc.targetTriple))
+        entry = lookup(ft->str());
+    if (!entry) entry = lookup(ctx.tc.targetTriple);
+    if (entry) {
+        c.tmpl = entry->runner;
         c.fromManifest = !ctx.manifest.buildConfig.runner.empty();
     }
     // `--no-runner` is the operator on THIS host stating a host fact the

tests/e2e/330_runner_hosted_targets.sh

@@ -42,12 +42,15 @@ cat > tests/one.cpp <<'EOF'
 int main() { return 0; }
 EOF
 
-# The host triple as the manifest spells it. Read from the engine rather than
-# guessed: `[target.<triple>]` is matched against the resolved target.
+# The host triple as the manifest spells it: the CANONICAL form, which is the
+# name of the output directory (`target/<triple>/…`) and the key every
+# `[target.<triple>]` reader resolves. Read from the engine rather than
+# guessed. Not the "Target … → …" status line: on macOS that prints the
+# driver's own spelling (`arm64-apple-darwin24.6.0`), which is not the key —
+# and the first version of this test used it and failed only on macOS.
 out=$("$MCPP" build 2>&1) || fail "initial build: $out"
-HOST=$(sed -n 's/.*Target \([^ ]*\) → .*/\1/p' <<<"$out" | head -1)
-[[ -n "$HOST" ]] || HOST=$(ls target | head -1)
-[[ -n "$HOST" ]] || fail "could not determine the host triple from: $out"
+HOST=$(ls target | head -1)
+[[ -n "$HOST" ]] || fail "could not determine the host triple from target/: $out"
 
 cat > "$TMP/runner.sh" <<'EOF'
 #!/bin/sh