fix(build): the generation carries the compiler cap, not build.ninja

A capped graph named its cap in every compile command, and the cap follows
the job count, so build.ninja differed between -j 1 and -j 4 (e2e 861). The
generation's owner record now carries the cap and every executor of the
generation reads it there; the fast path opens its generation with the cap
its first drive left beside build.ninja, and replans without one. Outside a
generation an executor takes --cap or MCPP_COMPILER_CAP.

The note for clang without coroutines on the 32-bit MSVC ABI looks for the
compiler after the executor's `--` (e2e 892).

Co-authored-by: speak-agent <248744407+speak-agent@users.noreply.github.com>

Author: Sunrisepeak

src/build/execute.cppm

@@ -2185,7 +2185,11 @@ std::optional<int> run_ninja_fast(const std::string& ninjaProgram,
         return text.find(" __compiler-cap ") != std::string::npos;
     }();
     if (capped) {
-        auto opened = mcpp::build::schedule::detach::RunScope::begin(outputDir);
+        // The graph names no cap; its first drive left it beside build.ninja.
+        // Without it the graph is replanned rather than run unbounded.
+        const int cap = mcpp::build::read_compiler_cap_sidecar(outputDir);
+        if (cap <= 0) return std::nullopt;
+        auto opened = mcpp::build::schedule::detach::RunScope::begin(outputDir, cap);
         if (!opened) { mcpp::ui::error(opened.error()); return 1; }
         compilerRun.emplace(std::move(*opened));
         compilerRun->environment(childEnv);

src/build/ninja_backend.cppm

@@ -318,6 +318,13 @@ void write_consumer_include_sidecar(const std::filesystem::path& outputDir,
 std::vector<std::filesystem::path>
 read_consumer_include_sidecar(const std::filesystem::path& outputDir);
 
+// The compiler cap of the generation a capped graph runs in, beside
+// build.ninja and not in it (e2e 861): the fast path replays the graph
+// without a plan and opens its generation with this cap. Removed when the
+// graph runs no compiler through the capped executor; 0 when absent.
+void write_compiler_cap_sidecar(const std::filesystem::path& outputDir, int cap);
+int read_compiler_cap_sidecar(const std::filesystem::path& outputDir);
+
 // #693 (M4): whether a Ninja reads build.ninja in the encoding mcpp writes it.
 //
 // mcpp writes the file in UTF-8: every path in it has a UTF-8 spelling
@@ -1180,6 +1187,21 @@ void write_consumer_include_sidecar(const std::filesystem::path& outputDir,
     for (auto const& d : dirs) f << d.string() << '\n';
 }
 
+constexpr std::string_view kCompilerCapSidecar = ".mcpp-compiler-cap";
+
+void write_compiler_cap_sidecar(const std::filesystem::path& outputDir, int cap) {
+    const auto path = outputDir / kCompilerCapSidecar;
+    std::error_code ec;
+    if (cap <= 0) { std::filesystem::remove(path, ec); return; }
+    std::ofstream(path, std::ios::binary | std::ios::trunc) << cap << '\n';
+}
+
+int read_compiler_cap_sidecar(const std::filesystem::path& outputDir) {
+    std::ifstream f(outputDir / kCompilerCapSidecar, std::ios::binary);
+    int cap = 0;
+    return f >> cap && cap > 0 ? cap : 0;
+}
+
 std::vector<std::filesystem::path>
 read_consumer_include_sidecar(const std::filesystem::path& outputDir) {
     std::vector<std::filesystem::path> dirs;
@@ -1474,8 +1496,10 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements,
     // larger slot count as their own concurrency bound.
     // Every capped graph (2026.11.7.1): the executor also registers each
     // compiler as a participant of the build's generation.
+    // No number of compilers here: the generation carries the cap, so the
+    // graph is the same whatever the job count (e2e 861).
     const std::string compilerPrefix = plan.scheduleCompilerCap > 0
-        ? std::format("$mcpp __compiler-cap --sem .mcpp-sched --cap {} --output $out --depfile $out.d -- ", plan.scheduleCompilerCap)
+        ? std::string("$mcpp __compiler-cap --sem .mcpp-sched --output $out --depfile $out.d -- ")
         : std::string{};
     // The other split shape. Clang publishes no BMI early — it writes the BMI
     // at the end of the compile — so the GCC trick of releasing the file
@@ -2113,7 +2137,7 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements,
         // wrong in this file before.
         append("rule cxx_module_bmi\n");
         append("  command = $mcpp bmi-compile --bmi $bmi_out --slot $slot"
-               " --self $mcpp --sem $sched_sem --cap $sched_cap --object $obj_out"
+               " --self $mcpp --sem $sched_sem --object $obj_out"
                " --command-file $out.cmd --dep-from $scan_dep --dep-to $out.d\n");
         append(std::format(
             "  rspfile = $out.cmd\n"
@@ -3204,7 +3228,6 @@ std::string emit_ninja_string(const BuildPlan& plan, std::string* placements,
                     e += "  slot = " + slot + "\n";
                     e += "  scan_dep = " + escape_ninja_path(ddi) + ".dep\n";
                     e += "  sched_sem = .mcpp-sched\n";
-                    e += std::format("  sched_cap = {}\n", plan.scheduleCompilerCap);
                     if (auto inc = local_include_flags(cu, dial); !inc.empty())
                         e += "  local_includes =" + inc + "\n";
                     if (auto fl = unit_cxx_flags(cu); !fl.empty())
@@ -4545,7 +4568,7 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
                                           plan.outputDir});
     std::optional<mcpp::build::schedule::detach::RunScope> compilerRun;
     if (!opts.dryRun && plan.scheduleCompilerCap > 0) {
-        auto opened = mcpp::build::schedule::detach::RunScope::begin(plan.outputDir);
+        auto opened = mcpp::build::schedule::detach::RunScope::begin(plan.outputDir, plan.scheduleCompilerCap);
         if (!opened) return std::unexpected(BuildError{opened.error(), plan.outputDir});
         compilerRun.emplace(std::move(*opened));
         reclaim_stale_schedule_tokens(plan.outputDir);
@@ -4561,6 +4584,7 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
         plan.targetSide.cAbiDecl ? plan.targetSide.cAbiDecl->absent
                                  : std::vector<mcpp::targetside::CAbiAbsentEntry>{});
     write_consumer_include_sidecar(plan.outputDir, root_include_dirs_of(plan));
+    write_compiler_cap_sidecar(plan.outputDir, plan.scheduleCompilerCap);
     write_graph_c_library_sidecar(plan.outputDir, plan.targetSide.cAbi);
     std::string placements;
     mcpp::build::progress::Attribution attribution;

src/build/schedule/detach_codegen.cppm

@@ -83,12 +83,18 @@ import mcpp.toolchain.fingerprint;
 export namespace mcpp::build::schedule::detach {
 
 inline constexpr std::string_view kRunEnv = "MCPP_COMPILER_RUN";
+// The cap of an executor that runs outside a generation (Ninja started by
+// hand), when its command line names none.
+inline constexpr std::string_view kCapEnv = "MCPP_COMPILER_CAP";
 
 // One runtime generation, outside the build identity. Its actor barrier covers
 // every helper that may write state, not only helpers holding compiler slots.
+// The generation carries the compiler cap: build.ninja names no number of
+// compilers, so the graph is the same whatever the job count (e2e 861), and
+// every executor of the generation reads the cap from its owner record.
 class RunScope {
 public:
-    static std::expected<RunScope, std::string> begin(const std::filesystem::path& outputDir);
+    static std::expected<RunScope, std::string> begin(const std::filesystem::path& outputDir, int compilerCap);
     RunScope(RunScope&&) noexcept;
     RunScope& operator=(RunScope&&) noexcept;
     ~RunScope();
@@ -194,6 +200,7 @@ struct Owner {
     bool managed = false;
     std::filesystem::path generation;
     mcpplibs::os::process::program program;
+    int cap = 0;  // the generation's compiler cap
 
     static Owner inherited() {
         Owner owner;
@@ -205,6 +212,7 @@ struct Owner {
         std::string version;
         if (!(record >> version >> owner.program.id >> owner.program.started_ns)
             || version != "mcpp-compiler-run-v1") owner.program = {};
+        else if (!(record >> owner.cap)) owner.cap = 0;
         return owner;
     }
     bool active() const {
@@ -332,8 +340,16 @@ struct Permit {
     std::filesystem::path reservation;
 };
 std::expected<Permit, int>
-acquire_permit(const Actor& actor, const std::filesystem::path& requested, int cap) {
+acquire_permit(const Actor& actor, const std::filesystem::path& requested, int requestedCap) {
     const auto dir = actor.owner.permits(requested);
+    const int cap = [&] {
+        if (actor.owner.managed) return actor.owner.cap;
+        if (requestedCap > 0) return requestedCap;
+        int fromEnv = 0;
+        if (const auto value = mcpp::invocation::get(kCapEnv))
+            std::from_chars(value->data(), value->data() + value->size(), fromEnv);
+        return fromEnv;
+    }();
     if (!actor.ready) return std::unexpected(130);
     if (dir.empty() || cap <= 0) {
         if (actor.owner.managed) return std::unexpected(2);
@@ -619,7 +635,8 @@ RunScope::RunScope(RunScope&&) noexcept = default;
 RunScope& RunScope::operator=(RunScope&&) noexcept = default;
 RunScope::~RunScope() = default;
 
-std::expected<RunScope, std::string> RunScope::begin(const std::filesystem::path& outputDir) {
+std::expected<RunScope, std::string> RunScope::begin(const std::filesystem::path& outputDir, int compilerCap) {
+    if (compilerCap <= 0) return std::unexpected("a compiler-run generation needs a compiler cap");
     const auto self = mcpplibs::os::process::self();
     if (!self || self->id == 0 || self->started_ns == 0)
         return std::unexpected("cannot identify the compiler-run owner and its birth time");
@@ -675,7 +692,7 @@ std::expected<RunScope, std::string> RunScope::begin(const std::filesystem::path
     auto witnesses = transactions::Witnesses::start(state->generation);
     if (!witnesses) return std::unexpected(witnesses.error());
     state->witnesses = std::move(*witnesses);
-    const auto record = std::format("mcpp-compiler-run-v1\n{} {}\n", self->id, self->started_ns);
+    const auto record = std::format("mcpp-compiler-run-v1\n{} {} {}\n", self->id, self->started_ns, compilerCap);
     if (!transactions::replace_record(state->generation / "owner", record))
         return std::unexpected("cannot publish compiler-run ownership");
     return RunScope(std::move(state));

src/cli.cppm

@@ -286,7 +286,7 @@ int run(int argc, char** argv) {
         for (; i < argc && std::string_view(argv[i]) != "--"; ++i) {
             const std::string_view option = argv[i];
             if ((option != "--sem" && option != "--cap" && option != "--output" && option != "--depfile") || i + 1 >= argc) {
-                std::println(stderr, "error: __compiler-cap: expected --sem <dir> --cap <N> -- <compiler>...");
+                std::println(stderr, "error: __compiler-cap: expected --sem <dir> [--cap <N>] -- <compiler>...");
                 return 2;
             }
             const std::string_view value = argv[++i];
@@ -298,7 +298,8 @@ int run(int argc, char** argv) {
                 if (ec != std::errc{} || end != value.data() + value.size()) return 2;
             }
         }
-        if (semaphore.empty() || cap <= 0 || i + 1 >= argc) return 2;
+        // No --cap: the generation's, or MCPP_COMPILER_CAP outside one.
+        if (semaphore.empty() || cap < 0 || i + 1 >= argc) return 2;
         std::vector<std::string> command;
         for (++i; i < argc; ++i) command.emplace_back(argv[i]);
         return mcpp::build::schedule::detach::run_capped(command, semaphore, cap, output, depfile);

src/toolchain/msvc_coroutines.cppm

@@ -173,6 +173,12 @@ std::optional<FailedCommand> failed_command_in(std::string_view output) {
     for_each_line(output, [&](std::string_view line) {
         if (auto at = line.find("command: "); at == 0) line.remove_prefix(9);
         auto words = split_words(line);
+        // A compile run through the capped executor (`<mcpp> __compiler-cap
+        // ... -- <compiler> ...`) names its compiler after the `--`.
+        if (words.size() > 1 && words[1] == "__compiler-cap") {
+            const auto end = std::ranges::find(words, std::string("--"));
+            words.erase(words.begin(), end == words.end() ? end : end + 1);
+        }
         if (words.empty() || !names_clang_driver(words.front())) return;
         FailedCommand cmd;
         cmd.compiler = words.front();

tests/e2e/helpers/check_shared_compiler_cap.py

@@ -132,11 +132,12 @@ def update(start):
         graph.write_text(text)
         env = os.environ.copy()
         env["MCPP_CAP_COUNTER"] = str(counter)
+        env["MCPP_COMPILER_CAP"] = str(cap)  # build.ninja names no cap; outside a generation it is this
         command = [ninja, "-j", str(cap * 6)]
         if owner_driver:
             env.update(GTEST_FILTER="DetachLifetime.SubprocessDriver",
                        MCPP_TEST_LIFETIME_ROLE="root", MCPP_TEST_LIFETIME_OUTPUT=str(build),
-                       MCPP_TEST_LIFETIME_NINJA_JOBS=str(cap*6))
+                       MCPP_TEST_LIFETIME_NINJA_JOBS=str(cap*6), MCPP_TEST_LIFETIME_CAP=str(cap))
             command=[str(owner_driver)]
         checked(command, build, log, env)
         semaphore = next((project/".mcpp/compiler-runs").glob("*/slots")) if owner_driver else build/".mcpp-sched"

tests/unit/test_detach_status.cpp

@@ -102,7 +102,9 @@ int lifetime_driver() {
             std::stoi(value("--cap")), value("--object"), command);
     }
     if (role == "root") {
-        auto run = detach::RunScope::begin(lifetime_env("MCPP_TEST_LIFETIME_OUTPUT", fs::current_path().string()));
+        // The generation's cap; build.ninja names none (e2e 861).
+        auto run = detach::RunScope::begin(lifetime_env("MCPP_TEST_LIFETIME_OUTPUT", fs::current_path().string()),
+                                           std::stoi(lifetime_env("MCPP_TEST_LIFETIME_CAP", "1")));
         if (!run) { std::println(std::cerr, "{}", run.error()); return 2; }
         std::ofstream("root.ready") << mcpplibs::os::process::self()->id;
         mcpp::run::Env env;

tests/unit/test_msvc_coroutines.cpp

@@ -127,6 +127,22 @@ TEST(MsvcCoroutines, CoroutineUseNoteDoesNotOfferCxx20) {
     EXPECT_NE(note.find("llvm@22.1.8"), std::string::npos);
 }
 
+// A compile run through the capped executor names its compiler after `--`.
+TEST(MsvcCoroutines, CoroutineUseThroughTheCappedExecutorGetsTheNote) {
+    constexpr std::string_view failure =
+        "FAILED: obj/main.o \n"
+        "C:/mcpp/bin/mcpp.exe __compiler-cap --sem .mcpp-sched --output obj/main.o --depfile obj/main.o.d -- "
+        "C:/Users/runneradmin/.mcpp/registry/data/xpkgs/xim-x-llvm/23.1.3/bin/clang++.exe @obj/main.o.rsp "
+        "-std=c++20 --target=i686-pc-windows-msvc -c D:/a/_temp/src/main.cpp -o obj/main.o\n"
+        "D:/a/_temp/src/main.cpp:2:71: error: use of undeclared identifier 'std'\n"
+        "D:/a/_temp/src/main.cpp:3:9: error: std::coroutine_traits type was not found; include <coroutine> before defining a coroutine\n";
+    auto cmd = co::failed_command_in(failure);
+    ASSERT_TRUE(cmd.has_value());
+    EXPECT_TRUE(cmd->compiler.ends_with("clang++.exe"));
+    EXPECT_EQ(cmd->target, "i686-pc-windows-msvc");
+    EXPECT_FALSE(co::advice(failure, answering(false)).empty());
+}
+
 TEST(MsvcCoroutines, CompilerThatPredefinesTheMacroGetsNoNote) {
     EXPECT_TRUE(co::advice(kStdModuleFailure, answering(true)).empty());
 }