fix: a dependency's [feature-xlings] tools must be installed before its build.mcpp runs

The root's `[xlings.workspace]` declarations are provisioned early. The GRAPH's
were provisioned about 1700 lines further down, after every build.mcpp had
already run. So a package that declares a tool under the feature that needs it
and then asks for it with `xpkg_dir` worked as the ROOT and was refused as a
DEPENDENCY -- with the very declaration it had already made quoted back at it.

Measured on the published `ggml-org:llamacpp@b10069.2`, which is exactly this
shape:

    [feature-xlings.backend-vulkan]
    "xim:shaderc" = "2026.3"

A consumer that writes the one line its README asks for could not build on a
clean machine:

    error: dependency 'llamacpp': build.mcpp exited with 2 (build aborted):
    ggml-org:llamacpp backend-vulkan needs glslc. Declare it: ...

With an isolated MCPP_HOME the unfixed engine pulled twenty-four xim payloads
for that graph and not shaderc; the fixed one pulls it and the consumer builds,
1921 shaders compiled.

WHY NOTHING CAUGHT IT. Once the tool is in the registry for any reason, and
building the package itself puts it there, `xpkg_dir` finds it and the ordering
stops mattering. llama.cpp-m's own CI builds it as the root; every machine that
had touched the package had the payload. Only an empty registry can see this,
which is what the sandbox run is for.

The split is now computed once, beside `activeFeaturesByPackage`, and read by
both the early provisioning pass and the later record-writing pass, so the two
cannot disagree about what "the graph declared" means. The late provisioning
call is kept: the stamp is keyed by content, so it is normally a hit, and it
remains the site that makes the record true if the early pass did not run.

e2e 618 is the criterion, and its first version was a false green worth
recording: it used `xim:ninja`, which mcpp installs to run its own builds, so
`xpkg_dir` answered on the broken engine too. It now uses the tool the defect
was actually found with.

Author: speak-agent

mcpp.toml

@@ -1,6 +1,6 @@
 [package]
 name        = "mcpp"
-version = "2026.9.6.3"
+version = "2026.9.6.4"
 description = "Modern C++ build & package management tool"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]

modules/versioning/src/version.cppm

@@ -31,6 +31,6 @@ import std;
 
 export namespace mcpp {
 
-inline constexpr std::string_view MCPP_VERSION = "2026.9.6.3";
+inline constexpr std::string_view MCPP_VERSION = "2026.9.6.4";
 
 } // namespace mcpp

src/build/prepare.cppm

@@ -3708,6 +3708,29 @@ prepare_build(bool print_fingerprint,
     // ask, and re-deriving it there would be a second copy of the aggregation
     // rule.
     std::vector<std::vector<std::string>> activeFeaturesByPackage;
+
+    // The split is computed HERE and reused by the late pass, so the two
+    // cannot disagree about what "the graph declared" means.
+    auto graph_xlings_split = [&] {
+        std::vector<std::string> rootSpecs = applicable_xlings_addresses(
+            runtimeOwnerManifest, activeFeaturesByPackage.empty()
+                ? std::vector<std::string>{} : activeFeaturesByPackage[0],
+            toolPurpose, /*isRoot=*/true);
+        std::vector<std::string> fromGraph;
+        for (std::size_t i = 0; i < packages.size(); ++i) {
+            const auto& man = packages[i].manifest;
+            const auto feats = i < activeFeaturesByPackage.size()
+                ? activeFeaturesByPackage[i] : std::vector<std::string>{};
+            for (auto const& spec : applicable_xlings_addresses(
+                     man, feats, toolPurpose, /*isRoot=*/i == 0)) {
+                if (std::ranges::find(rootSpecs, spec) != rootSpecs.end())
+                    continue;
+                if (std::ranges::find(fromGraph, spec) == fromGraph.end())
+                    fromGraph.push_back(spec);
+            }
+        }
+        return std::pair{std::move(rootSpecs), std::move(fromGraph)};
+    };
     packages.push_back({*root, *m});
 
     // dep_manifests is kept around purely so the build plan can move it
@@ -7034,6 +7057,43 @@ prepare_build(bool print_fingerprint,
         }
         activeFeaturesByPackage.resize(packages.size());
 
+        // ── The GRAPH's `[xlings.workspace]`, provisioned BEFORE build.mcpp ──
+        //
+        // Same ordering rule as the host-tool block directly below, and for the
+        // same reason: a build program consumes what was provisioned, so
+        // provisioning after it has run is provisioning that did not happen.
+        //
+        // MEASURED, on the published `ggml-org:llamacpp@b10069.2`. That package
+        // declares its shader compiler under the feature that needs it:
+        //
+        //     [feature-xlings.backend-vulkan]
+        //     "xim:shaderc" = "2026.3"
+        //
+        // and its build program asks for it with `xpkg_dir`. As the ROOT it
+        // works, because the root's pass runs early. As a DEPENDENCY it did
+        // not: the graph's pass ran ~1700 lines further down, after every
+        // build.mcpp, so `xpkg_dir` answered "" and the package refused its own
+        // headline feature with the very declaration it had already made. A
+        // clean `MCPP_HOME` pulled twenty-four xim payloads for that graph and
+        // not shaderc.
+        //
+        // IT WAS INVISIBLE ON ANY MACHINE THAT HAD BUILT THE PACKAGE ITSELF.
+        // Once `xim:shaderc` is in the registry for any reason, `xpkg_dir`
+        // finds it and the ordering stops mattering; only an empty registry can
+        // see this. The sandbox run is what caught it.
+        //
+        {
+            auto [_rootSpecs, fromGraph] = graph_xlings_split();
+            if (!fromGraph.empty()) {
+                if (auto cfg = get_cfg()) {
+                    if (auto pv = provision_xlings_addresses(
+                            **cfg, fromGraph, *root,
+                            "[xlings.workspace] entries declared by dependencies");
+                        !pv) return std::unexpected(pv.error());
+                }
+            }
+        }
+
         // ── #355: HOST tool provisioning ────────────────────────────────────
         //
         // Runs AFTER feature activation (a tool target's gate is a feature) and
@@ -9301,31 +9361,21 @@ prepare_build(bool print_fingerprint,
     // and never acted on. The two definitions are one expression below, so
     // they cannot drift — the third of the three hazards §12.6 named.
     {
-        std::vector<std::string> xlingsSpecs = applicable_xlings_addresses(
-            runtimeOwnerManifest, activeFeaturesByPackage.empty()
-                ? std::vector<std::string>{} : activeFeaturesByPackage[0],
-            toolPurpose, /*isRoot=*/true);
-        // Everything the GRAPH declared, on the tiers this verb needs. `isRoot`
-        // is false for every one of them, which is what makes `when = "dev"`
-        // stop at the package that wrote it.
-        std::vector<std::string> fromGraph;
-        for (std::size_t i = 0; i < packages.size(); ++i) {
-            const auto& man = packages[i].manifest;
-            const auto feats = i < activeFeaturesByPackage.size()
-                ? activeFeaturesByPackage[i] : std::vector<std::string>{};
-            for (auto const& spec : applicable_xlings_addresses(
-                     man, feats, toolPurpose, /*isRoot=*/i == 0)) {
-                if (std::ranges::find(xlingsSpecs, spec) != xlingsSpecs.end())
-                    continue;
-                if (std::ranges::find(fromGraph, spec) == fromGraph.end())
-                    fromGraph.push_back(spec);
-            }
-        }
+        // THE SAME SPLIT THE EARLY PASS USED. Written once, above, next to the
+        // provisioning that has to happen before build.mcpp; this site reads it
+        // for the records below. Two copies of "what did the graph declare"
+        // would be two definitions of the same word.
+        auto [xlingsSpecs, fromGraph] = graph_xlings_split();
         // THE ROOT'S OWN PASS RAN LONG AGO, AND THIS ONE MUST NOT REPEAT IT.
         // The stamp is keyed by the LIST, so provisioning root+graph together
         // would key a different list than the early pass wrote and re-run an
         // xlings round trip on every build. Only what the graph added is
         // provisioned here, under its own key.
+        //
+        // Since the graph's pass moved above build.mcpp this call is normally a
+        // stamp hit. It is kept rather than deleted because the stamp is keyed
+        // by content: if the early pass did not run, or ran on a different
+        // list, this is still the site that makes the record true.
         if (!fromGraph.empty()) {
             if (auto cfg = get_cfg()) {
                 if (auto pv = provision_xlings_addresses(

tests/e2e/618_dependency_feature_tools_reach_its_build_program.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# requires: elf gcc
+# A DEPENDENCY's `[feature-xlings.<f>]` must be installed before that
+# dependency's build.mcpp runs.
+#
+# THE ROOT AND A DEPENDENCY WERE NOT THE SAME PATH. The root's declarations are
+# provisioned early; the graph's were provisioned ~1700 lines further down, after
+# every build.mcpp had already run. A package that declares a tool under the
+# feature that needs it and then asks for it with `xpkg_dir` therefore worked as
+# the root and was refused as a dependency -- with the very declaration it had
+# already made quoted back at it.
+#
+# Measured on the published `ggml-org:llamacpp@b10069.2`: a clean MCPP_HOME
+# pulled twenty-four xim payloads for that graph and not `xim:shaderc`.
+#
+# WHY IT SURVIVED EVERY OTHER CHECK. Once the tool is in the registry for any
+# reason -- and building the package itself puts it there -- `xpkg_dir` finds it
+# and the ordering stops mattering. The package's own CI builds it as the ROOT.
+# Only a registry that has never seen it can tell, which is why this test uses
+# an isolated MCPP_HOME rather than the ambient one.
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+# THE TOOL MUST BE ONE mcpp DOES NOT INSTALL FOR ITS OWN REASONS.
+#
+# The first version of this test used `xim:ninja`, and it passed on the broken
+# engine: mcpp installs ninja to run its own builds, so `xpkg_dir` answered
+# whether or not the feature had been provisioned. The criterion had selected an
+# object that is present for an unrelated reason -- it could never have failed.
+#
+# Measured: a minimal isolated MCPP_HOME holds binutils, gcc, gcc-runtime,
+# gcc-specs-config, glibc, linux-headers, ninja and patchelf. `shaderc` is in
+# none of that, is 16M, and is the tool the real defect was found with.
+TOOL=shaderc
+TOOL_VERSION="2026.3"
+
+mkdir -p dep/src
+cat > dep/src/lib.cpp <<'EOF'
+int dep_touch() { return 1; }
+EOF
+cat > dep/build.mcpp <<EOF
+#include <cstdio>
+#include <string>
+import mcpp;
+int main() {
+    // THE ASSERTION IS HERE, in the dependency's own build program: the tool it
+    // declared under an active feature has to be findable by the time it runs.
+    const char* d = mcpp::xpkg_dir("xim", "$TOOL");
+    if (d == nullptr || d[0] == '\0') {
+        std::fprintf(stderr,
+            "a dependency's [feature-xlings] tool was not provisioned before "
+            "its build.mcpp ran\n");
+        return 2;
+    }
+    // TO A FILE, NOT TO stdout. mcpp prints a build program's output only when
+    // it FAILS, so an assertion that grepped the build log for this line would
+    // be unreachable on exactly the run that is supposed to produce it.
+    std::string out = std::string(mcpp::manifest_dir()) + "/tool-seen.txt";
+    std::FILE* f = std::fopen(out.c_str(), "w");
+    if (f == nullptr) return 3;
+    std::fprintf(f, "%s\n", d);
+    std::fclose(f);
+    return 0;
+}
+EOF
+cat > dep/mcpp.toml <<EOF
+[package]
+name    = "featuretool"
+version = "0.1.0"
+[modules]
+sources = ["src/**/*.cpp"]
+[features]
+default   = []
+usestool  = []
+[feature-xlings.usestool]
+"xim:$TOOL" = "$TOOL_VERSION"
+[targets.featuretool]
+kind = "lib"
+EOF
+
+mkdir -p app/src
+cat > app/src/main.cpp <<'EOF'
+int main() { return 0; }
+EOF
+cat > app/mcpp.toml <<'EOF'
+[package]
+name    = "consumer"
+version = "0.1.0"
+[dependencies]
+featuretool = { path = "../dep", features = ["usestool"] }
+[targets.consumer]
+kind = "bin"
+main = "src/main.cpp"
+EOF
+
+# AN ISOLATED HOME IS THE POINT. The ambient registry very likely holds the
+# tool already, and then this test passes on a broken engine.
+export MCPP_HOME="$TMP/home"
+mkdir -p "$MCPP_HOME"
+
+cd app
+if ! "$MCPP" build >build.log 2>&1; then
+    echo "FAIL: the consumer did not build"
+    grep -iE 'not provisioned|error' build.log | head -5
+    exit 1
+fi
+seen="$TMP/dep/tool-seen.txt"
+[ -s "$seen" ] || {
+    echo "FAIL: the dependency's build program left no record of finding its tool"
+    tail -10 build.log
+    exit 1
+}
+echo "the dependency's build program saw its tool at: $(cat "$seen")"
+grep -q "xim-x-$TOOL" "$seen" || {
+    echo "FAIL: the recorded path does not name $TOOL: $(cat "$seen")"
+    exit 1
+}
+echo "PASS: a dependency's [feature-xlings] tool is provisioned before its build.mcpp runs"