fix: runner was reported as an ignored key while being honoured, and CI installed the emulator into one home

Two things CI found that local runs could not.

* `[target.<triple>].runner` drew "unsupported key 'runner' (ignored)". The
  unknown-key sweep is about SCALARS — "a scalar that does nothing" — and it
  skipped tables but not arrays, so an array key the parser reads a few lines
  earlier was announced as ignored. Saying a working key does nothing is worse
  than either statement being true on its own. Two tests pin it: the key parses
  and warns about nothing, and the two shapes that would run nothing (an empty
  array, a bare string) are still errors.

* The bare-metal job installed the emulator into the ambient xlings home only,
  and `mcpp run` answered

      [error] xlings: 'qemu-system-riscv64' is not installed

  even though the shim was on PATH. A shim dispatches against whichever home
  owns it, and `mcpp run` goes through that shim — so the emulator has to be in
  the home MCPP uses, exactly like the sysroot two steps below it. Installed
  into both now, with the `--version` probe kept as the before-the-fact check.

Author: speak-agent

.github/workflows/ci-linux-e2e.yml

@@ -132,10 +132,18 @@ jobs:
 
       - name: Install the emulator (xim:qemu-riscv)
         run: |
+          # ⚠️ BOTH homes. The shim on PATH dispatches against whichever home
+          # owns it, and `mcpp run` runs the runner through that shim — so an
+          # emulator installed only in the ambient xlings home answers
+          # "xlings: 'qemu-system-riscv64' is not installed" when mcpp asks.
+          # Measured: the job installed it once, the shim resolved, and the
+          # run still failed.
           "$XLINGS_BIN" install xim:qemu-riscv -y
-          # Assert it is reachable BEFORE the suite runs. Without this the
-          # capability probe simply would not add `qemu-riscv`, and the test
-          # would skip — which is what this job exists to prevent.
+          XLINGS_HOME="${MCPP_HOME:-$HOME/.mcpp}/registry" \
+            "$XLINGS_BIN" install xim:qemu-riscv -y
+          # Assert it is reachable AND runnable BEFORE the tests. Without this
+          # the capability probe simply would not add `qemu-riscv` and the
+          # tests would skip — which is what this job exists to prevent.
           command -v qemu-system-riscv64
           qemu-system-riscv64 --version | head -1
           # The target sysroot, into the home MCPP uses. Test 131's BSP

src/manifest/toml.cppm

@@ -1460,6 +1460,12 @@ std::expected<Manifest, ManifestError> parse_string(std::string_view content,
             };
             for (auto& [key, value] : body) {
                 if (value.is_table()) continue;   // the conditional channel
+                // ...and arrays, which this sweep was never about. It checks
+                // SCALARS ("a scalar that does nothing"), and `runner` is an
+                // array read a few lines above — reaching here it was reported
+                // as "unsupported key 'runner' (ignored)" while in fact being
+                // honoured, which is worse than either being true.
+                if (value.is_array()) continue;
                 bool known = false;
                 for (auto k : kKnownTargetScalars) if (key == k) { known = true; break; }
                 if (known) continue;

tests/unit/test_manifest.cpp

@@ -3590,3 +3590,52 @@ defines = ["FOO=1"]
     // ...and the field itself is gone, so nothing downstream can read it.
     EXPECT_EQ(m->targetOverrides.at("x86_64-linux-gnu").cxxRuntime, "");
 }
+
+// ── [target.<triple>].runner ────────────────────────────────────────────────
+
+TEST(Manifest, TargetRunnerParsesAndDoesNotWarn) {
+    constexpr auto src = R"(
+[package]
+name = "fw"
+version = "0.1.0"
+
+[target.riscv64-none-elf]
+runner = ["qemu-system-riscv64", "-machine", "virt", "-kernel"]
+)";
+    auto m = mcpp::manifest::parse_string(src);
+    ASSERT_TRUE(m.has_value()) << m.error().format();
+    auto it = m->targetOverrides.find("riscv64-none-elf");
+    ASSERT_NE(it, m->targetOverrides.end());
+    ASSERT_EQ(it->second.runner.size(), 4u);
+    EXPECT_EQ(it->second.runner.front(), "qemu-system-riscv64");
+    EXPECT_EQ(it->second.runner.back(),  "-kernel");
+    // ⚠️ The unknown-key sweep is about SCALARS ("a scalar that does
+    // nothing"). It skipped tables but not arrays, so this key was reported as
+    // "unsupported key 'runner' (ignored)" while in fact being honoured —
+    // worse than either statement being true. Seen in CI.
+    EXPECT_TRUE(m->schemaWarnings.empty())
+        << (m->schemaWarnings.empty() ? "" : m->schemaWarnings[0]);
+}
+
+TEST(Manifest, TargetRunnerRejectsShapesThatWouldRunNothing) {
+    // An empty template would exec nothing and report success.
+    constexpr auto empty = R"(
+[package]
+name = "fw"
+version = "0.1.0"
+[target.riscv64-none-elf]
+runner = []
+)";
+    EXPECT_FALSE(mcpp::manifest::parse_string(empty).has_value());
+
+    // A bare string is the shape a user reaches for first; taking it would
+    // mean guessing where the word boundaries are.
+    constexpr auto scalar = R"(
+[package]
+name = "fw"
+version = "0.1.0"
+[target.riscv64-none-elf]
+runner = "qemu-system-riscv64 -kernel"
+)";
+    EXPECT_FALSE(mcpp::manifest::parse_string(scalar).has_value());
+}