the absent-facility advice reaches both channels a failed build reports through

A build reports failure on two paths: the one with a plan, and the fast path,
which has none by construction. `ninja_backend.cppm` already records why that
matters for `link_failure_advice` --- advice attached to only one of them
"would appear or not depending on whether build.ninja happened to be up to
date, which is exactly the kind of 'same decision in two places' this codebase
keeps paying for" --- and the new `[c-abi.absent]` advice had been attached to
one.

The list travels between them in a file beside build.ninja, written when the
plan emits it and opened only after a build has already failed. The fast path's
purpose is to read as little as possible, so it reads nothing extra until
there is a failure to explain.

A graph that declares no absence removes the file rather than leaving it: a
stale one would let the fast path explain a failure with a list the current
graph never declared.

Co-authored-by: Claude Code <noreply@anthropic.com>

Author: speak-agent

src/build/execute.cppm

@@ -1258,6 +1258,19 @@ std::optional<int> run_ninja_fast(const std::string& ninjaProgram,
         if (auto advice = mcpp::build::graph_c_library_isolation_advice(out);
             !advice.empty())
             std::fputs(advice.c_str(), stderr);
+        // THE SAME ADVICE THE PLAN PATH GIVES, FROM THE LIST THE PLAN WROTE
+        // DOWN. This path has no `BuildPlan` by construction, so the C
+        // library's `[c-abi.absent]` table reaches it through a file beside
+        // build.ninja rather than through a resolution it exists to skip.
+        // Advice attached to one path only appears or not depending on
+        // whether build.ninja happened to be up to date.
+        {
+            auto [cAbiName, absent] = mcpp::build::read_c_abi_absent_sidecar(
+                ninjaPath.parent_path());
+            if (auto advice = mcpp::build::c_abi_absent_facility_advice(
+                    out, cAbiName, absent); !advice.empty())
+                std::fputs(advice.c_str(), stderr);
+        }
         return 1;
     }
     if (verbose && !out.empty())

src/build/ninja_backend.cppm

@@ -111,6 +111,26 @@ std::string c_abi_absent_facility_advice(
     std::string_view output, std::string_view cAbiName,
     const std::vector<mcpp::targetside::CAbiAbsentEntry>& absent);
 
+// THE SAME ADVICE ON BOTH PATHS, WHICH IS WHY THE LIST IS WRITTEN DOWN.
+//
+// A build reports failure through two channels: this one, which has a plan,
+// and the fast path (`mcpp.build.execute`), which deliberately has none. An
+// advice attached to only one of them appears or not depending on whether
+// build.ninja happened to be up to date, which is the same decision in two
+// places wearing a different hat. The plan writes the list beside build.ninja;
+// the fast path reads it back and calls the same function.
+//
+// It is a plain file rather than a field in an existing record because the
+// fast path's whole purpose is to read as little as possible: this one is
+// opened only after a build has already failed.
+void write_c_abi_absent_sidecar(
+    const std::filesystem::path& outputDir, std::string_view cAbiName,
+    const std::vector<mcpp::targetside::CAbiAbsentEntry>& absent);
+
+// `{name, absent}` read back, or an empty pair when no build wrote one.
+std::pair<std::string, std::vector<mcpp::targetside::CAbiAbsentEntry>>
+read_c_abi_absent_sidecar(const std::filesystem::path& outputDir);
+
 // mcpp#662: the compile-side sibling of `link_failure_advice`, same shape —
 // text-matched against RAW ninja output (command lines included; the caller
 // must not pass the filtered form), returning advice to APPEND, never
@@ -686,6 +706,48 @@ std::string link_failure_advice(std::string_view output) {
         "      `std::align_val_t`, which are the ones most often forgotten.\n";
 }
 
+namespace {
+constexpr std::string_view kCAbiAbsentSidecar = ".mcpp-c-abi-absent";
+}
+
+void write_c_abi_absent_sidecar(
+    const std::filesystem::path& outputDir, std::string_view cAbiName,
+    const std::vector<mcpp::targetside::CAbiAbsentEntry>& absent) {
+    const auto path = outputDir / kCAbiAbsentSidecar;
+    std::error_code ec;
+    if (absent.empty()) { std::filesystem::remove(path, ec); return; }
+    std::ofstream f(path, std::ios::binary | std::ios::trunc);
+    if (!f) return;
+    f << cAbiName << '\n';
+    for (auto const& e : absent)
+        f << mcpp::targetside::c_abi_absent_form_name(e.form) << '\t'
+          << e.name << '\t' << e.note << '\n';
+}
+
+std::pair<std::string, std::vector<mcpp::targetside::CAbiAbsentEntry>>
+read_c_abi_absent_sidecar(const std::filesystem::path& outputDir) {
+    std::pair<std::string, std::vector<mcpp::targetside::CAbiAbsentEntry>> out;
+    std::ifstream f(outputDir / kCAbiAbsentSidecar, std::ios::binary);
+    if (!f) return out;
+    std::getline(f, out.first);
+    std::string line;
+    while (std::getline(f, line)) {
+        if (line.empty()) continue;
+        const auto a = line.find('\t');
+        if (a == std::string::npos) continue;
+        const auto b = line.find('\t', a + 1);
+        if (b == std::string::npos) continue;
+        auto form = mcpp::targetside::parse_c_abi_absent_form(line.substr(0, a));
+        if (!form) continue;
+        mcpp::targetside::CAbiAbsentEntry e;
+        e.form = *form;
+        e.name = line.substr(a + 1, b - a - 1);
+        e.note = line.substr(b + 1);
+        out.second.push_back(std::move(e));
+    }
+    return out;
+}
+
 std::string c_abi_absent_facility_advice(
     std::string_view output, std::string_view cAbiName,
     const std::vector<mcpp::targetside::CAbiAbsentEntry>& absent) {
@@ -3097,6 +3159,14 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
                                           plan.outputDir});
 
     auto ninja_path = plan.outputDir / "build.ninja";
+    // Written beside build.ninja and not into it: the fast path replays the
+    // ninja file without a plan, and the advice a failed link needs has to
+    // reach both channels or it appears depending on whether build.ninja
+    // happened to be up to date.
+    write_c_abi_absent_sidecar(
+        plan.outputDir, plan.targetSide.cAbi.interfaceName,
+        plan.targetSide.cAbiDecl ? plan.targetSide.cAbiDecl->absent
+                                 : std::vector<mcpp::targetside::CAbiAbsentEntry>{});
     auto manifest = emit_ninja_string(plan);
     stage("emit-ninja");
 
@@ -3465,6 +3535,8 @@ std::expected<BuildResult, BuildError> NinjaBackend::build(const BuildPlan& plan
             diagnostics += c_abi_absent_facility_advice(
                 out, plan.targetSide.cAbi.interfaceName,
                 plan.targetSide.cAbiDecl->absent);
+        // (the fast path reads the same list from the sidecar this build
+        // wrote beside build.ninja — see `write_c_abi_absent_sidecar`)
         return std::unexpected(BuildError{"build failed", plan.outputDir / "build.ninja",
                                           std::move(diagnostics)});
     }

tests/unit/test_build_flags.cpp

@@ -281,3 +281,47 @@ TEST(CAbiAbsentAdvice, ALongerSymbolWithTheSamePrefixIsNotExplained) {
     EXPECT_FALSE(mcpp::build::c_abi_absent_facility_advice(
         "ld.lld: error: undefined symbol: open\n", "musl", absent).empty());
 }
+
+TEST(CAbiAbsentAdvice, TheListSurvivesAWriteAndReadBesideBuildNinja) {
+    // The two paths that report a failed build --- the one with a plan and the
+    // fast path, which has none by construction --- must give the same advice,
+    // or it appears depending on whether build.ninja happened to be up to
+    // date. The list travels between them in a file.
+    Tmp dir;
+    std::vector<mcpp::targetside::CAbiAbsentEntry> absent{
+        {"fork", mcpp::targetside::CAbiAbsentForm::Link, "no image duplication"},
+        {"mprotect", mcpp::targetside::CAbiAbsentForm::Enosys, ""},
+    };
+    mcpp::build::write_c_abi_absent_sidecar(dir.path, "musl", absent);
+    auto [name, back] = mcpp::build::read_c_abi_absent_sidecar(dir.path);
+    EXPECT_EQ(name, "musl");
+    ASSERT_EQ(back.size(), 2u);
+    EXPECT_EQ(back[0].name, "fork");
+    EXPECT_EQ(back[0].form, mcpp::targetside::CAbiAbsentForm::Link);
+    EXPECT_EQ(back[0].note, "no image duplication");
+    EXPECT_EQ(back[1].form, mcpp::targetside::CAbiAbsentForm::Enosys);
+    EXPECT_TRUE(back[1].note.empty());
+    // And the advice built from the read-back list is the advice the plan
+    // path would have given.
+    EXPECT_FALSE(mcpp::build::c_abi_absent_facility_advice(
+        "ld.lld: error: undefined symbol: fork\n", name, back).empty());
+}
+
+TEST(CAbiAbsentAdvice, ADirectoryNoBuildWroteToYieldsNothing) {
+    Tmp dir;
+    auto [name, back] = mcpp::build::read_c_abi_absent_sidecar(dir.path);
+    EXPECT_TRUE(name.empty());
+    EXPECT_TRUE(back.empty());
+}
+
+TEST(CAbiAbsentAdvice, AGraphThatDeclaresNoAbsenceLeavesNoSidecar) {
+    // A build whose C library states nothing must not leave a file behind for
+    // the next build to read: the fast path would then explain a failure with
+    // a list the current graph never declared.
+    Tmp dir;
+    mcpp::build::write_c_abi_absent_sidecar(dir.path, "musl",
+        {{"fork", mcpp::targetside::CAbiAbsentForm::Link, ""}});
+    mcpp::build::write_c_abi_absent_sidecar(dir.path, "", {});
+    auto [name, back] = mcpp::build::read_c_abi_absent_sidecar(dir.path);
+    EXPECT_TRUE(back.empty());
+}