fix: payload probe falls back to the active home registry

probe_payload_paths found glibc/linux-headers only as compiler SIBLINGS.
With an inherited (symlinked) compiler the binary resolves into its owner
home, so sysroot payloads freshly installed into the ACTIVE home (first-run
default path) were invisible -> std module precompile failed with
stdlib.h not found (CI fresh-home e2e 29/31). Add
paths::active_home_xpkgs()/find_home_tool() and consult them after sibling
search: discovery = compiler siblings ∪ active home registry.

Author: d2learn-org

src/toolchain/probe.cppm

@@ -303,8 +303,12 @@ std::optional<PayloadPaths>
 probe_payload_paths(const std::filesystem::path& compilerBin) {
     namespace paths = mcpp::xlings::paths;
 
-    // Find glibc xpkg (required).
+    // Find glibc xpkg (required). Compiler siblings first; fall back to the
+    // ACTIVE home registry — an inherited/symlinked compiler resolves into
+    // its owner home, while the active home may own (or have just installed)
+    // the sysroot payloads.
     auto glibc = paths::find_sibling_tool(compilerBin, "glibc");
+    if (!glibc) glibc = paths::find_home_tool("glibc");
     if (!glibc) return std::nullopt;
 
     // Glibc layout: <root>/include/ + <root>/lib64/ (or lib/).
@@ -322,8 +326,10 @@ probe_payload_paths(const std::filesystem::path& compilerBin) {
     pp.glibcInclude = glibcInclude;
     pp.glibcLib     = glibcLib;
 
-    // Find linux kernel headers (optional — search across index prefixes).
+    // Find linux kernel headers (optional — search across index prefixes,
+    // then the active home registry).
     auto linuxHeaders = paths::find_sibling_package(compilerBin, "linux-headers");
+    if (!linuxHeaders) linuxHeaders = paths::find_home_tool("linux-headers");
     if (linuxHeaders) {
         auto linuxInclude = *linuxHeaders / "include";
         if (std::filesystem::exists(linuxInclude / "linux" / "limits.h"))

src/xlings.cppm

@@ -82,6 +82,15 @@ namespace paths {
     find_sibling_package(const std::filesystem::path& compilerBin,
                          std::string_view packageName);
 
+    // xpkgs root of the ACTIVE mcpp home ($MCPP_HOME or ~/.mcpp). Payload
+    // discovery consults this in addition to compiler siblings: an
+    // inherited/symlinked compiler resolves into its owner home, while the
+    // active home may own (or have just installed) the sysroot payloads.
+    std::optional<std::filesystem::path> active_home_xpkgs();
+
+    // Like find_sibling_tool, but anchored at the active home's xpkgs.
+    std::optional<std::filesystem::path> find_home_tool(std::string_view tool);
+
     // index data root: env.home / "data"
     std::filesystem::path index_data(const Env& env);
 
@@ -519,6 +528,35 @@ find_sibling_tool(const std::filesystem::path& compilerBin,
     return std::nullopt;
 }
 
+std::optional<std::filesystem::path> active_home_xpkgs() {
+    std::filesystem::path home;
+    if (const char* h = std::getenv("MCPP_HOME"); h && *h) {
+        home = h;
+    } else if (const char* u = std::getenv("HOME"); u && *u) {
+        home = std::filesystem::path(u) / ".mcpp";
+    } else {
+        return std::nullopt;
+    }
+    auto xpkgs = home / "registry" / "data" / "xpkgs";
+    std::error_code ec;
+    if (!std::filesystem::exists(xpkgs, ec)) return std::nullopt;
+    return xpkgs;
+}
+
+std::optional<std::filesystem::path> find_home_tool(std::string_view tool) {
+    auto xpkgs = active_home_xpkgs();
+    if (!xpkgs) return std::nullopt;
+
+    auto root = *xpkgs / std::format("xim-x-{}", tool);
+    std::error_code ec;
+    if (!std::filesystem::exists(root, ec)) return std::nullopt;
+
+    for (auto& v : std::filesystem::directory_iterator(root, ec)) {
+        if (v.is_directory(ec)) return v.path();
+    }
+    return std::nullopt;
+}
+
 std::optional<std::filesystem::path>
 find_sibling_binary(const std::filesystem::path& compilerBin,
                     std::string_view tool,