fix: build cache must invalidate when --target changes

The P0 fast-path build cache (target/.build_cache) only checked source
file and mcpp.toml timestamps.  When `mcpp build --target x86_64-linux-musl`
was followed by a plain `mcpp build`, the fast-path reused the musl
build.ninja — producing no GNU binary.

Fix: store the user's --target value as a third line in .build_cache.
try_fast_build() now compares the cached target against the current
request and falls back to a full rebuild on mismatch.

Also fix the test: detect installed GNU gcc dynamically and pin it in
[toolchain].linux so the default build uses GNU, not musl auto-install.

Author: Sunrisepeak

src/cli.cppm

@@ -2039,21 +2039,24 @@ constexpr std::string_view kBuildCacheFile = "target/.build_cache";
 
 void write_build_cache(const std::filesystem::path& projectRoot,
                        const std::filesystem::path& outputDir,
-                       const std::string& ninjaProgram) {
+                       const std::string& ninjaProgram,
+                       const std::string& targetTriple) {
     auto path = projectRoot / kBuildCacheFile;
     std::error_code ec;
     std::filesystem::create_directories(path.parent_path(), ec);
     std::ofstream f(path, std::ios::trunc);
     if (f) {
         f << outputDir.string() << '\n';
         f << ninjaProgram << '\n';
+        f << targetTriple << '\n';
     }
 }
 
 // Compile a prepared BuildContext. Shared between `mcpp build` and `mcpp run`
 // so the latter doesn't call prepare_build twice (and re-print the toolchain
 // resolution banner).
-int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache) {
+int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache,
+                   std::string_view targetOverride = "") {
     if (no_cache) {
         std::error_code ec;
         std::filesystem::remove_all(ctx.outputDir, ec);
@@ -2106,7 +2109,8 @@ int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache) {
 
     // P0: save build cache for fast-path on next invocation.
     if (!no_cache && !r->ninjaProgram.empty()) {
-        write_build_cache(ctx.projectRoot, ctx.outputDir, r->ninjaProgram);
+        write_build_cache(ctx.projectRoot, ctx.outputDir, r->ninjaProgram,
+                          std::string(targetOverride));
     }
 
     mcpp::ui::finished("release", r->elapsed);
@@ -2125,17 +2129,24 @@ int run_build_plan(BuildContext& ctx, bool verbose, bool no_cache) {
 // Try to fast-path: if build.ninja is newer than all inputs, just run ninja.
 // Returns exit code on fast-path, or nullopt if full rebuild needed.
 std::optional<int> try_fast_build(const std::filesystem::path& projectRoot,
-                                  bool verbose, bool no_cache) {
+                                  bool verbose, bool no_cache,
+                                  std::string_view currentTarget = "") {
     if (no_cache) return std::nullopt;
 
     auto cachePath = projectRoot / kBuildCacheFile;
     std::error_code ec;
     if (!std::filesystem::exists(cachePath, ec)) return std::nullopt;
 
     std::ifstream f(cachePath);
-    std::string outputDirStr, ninjaProgram;
+    std::string outputDirStr, ninjaProgram, cachedTarget;
     if (!std::getline(f, outputDirStr) || outputDirStr.empty()) return std::nullopt;
     if (!std::getline(f, ninjaProgram) || ninjaProgram.empty()) return std::nullopt;
+    std::getline(f, cachedTarget); // may be empty for old cache files
+
+    // Reject cache if target triple changed (e.g. previous build used
+    // --target x86_64-linux-musl but this one is a default build).
+    if (cachedTarget != currentTarget) return std::nullopt;
+
     std::filesystem::path outputDir(outputDirStr);
 
     auto ninjaPath = outputDir / "build.ninja";
@@ -2214,7 +2225,7 @@ int cmd_build(const mcpplibs::cmdline::ParsedArgs& parsed) {
     auto ctx = prepare_build(print_fp, /*includeDevDeps=*/false, /*extraTargets=*/{}, ov);
     if (!ctx) { std::println(stderr, "error: {}", ctx.error()); return 2; }
 
-    return run_build_plan(*ctx, verbose, no_cache);
+    return run_build_plan(*ctx, verbose, no_cache, ov.target_triple);
 }
 
 int cmd_run(const mcpplibs::cmdline::ParsedArgs& parsed,

tests/e2e/28_target_static.sh

@@ -28,13 +28,6 @@ if [[ -d "$XPKGS/xim-x-gcc" ]]; then
     GNU_GCC_VER=$(ls "$XPKGS/xim-x-gcc" 2>/dev/null | sort -V | tail -1)
 fi
 
-# Diagnostic: show what we detected
-echo "DIAG: MCPP_HOME=${MCPP_HOME:-<unset>}"
-echo "DIAG: XPKGS=$XPKGS"
-echo "DIAG: GNU_GCC_VER=${GNU_GCC_VER:-<empty>}"
-echo "DIAG: xim-x-gcc contents: $(ls "$XPKGS/xim-x-gcc" 2>&1 || echo 'N/A')"
-echo "DIAG: config.toml toolchain line: $(grep -i toolchain "${MCPP_HOME:-$HOME/.mcpp}/config.toml" 2>/dev/null || echo 'none')"
-
 TMP=$(mktemp -d)
 trap "rm -rf $TMP" EXIT
 
@@ -64,9 +57,6 @@ linkage   = "static"
 EOF
 fi
 
-echo "DIAG: mcpp.toml:"
-cat mcpp.toml
-
 "$MCPP" build --target x86_64-linux-musl > build.log 2>&1 || {
     cat build.log; echo "build failed"; exit 1; }
 
@@ -96,8 +86,6 @@ fi
 if [[ -n "$GNU_GCC_VER" ]]; then
     "$MCPP" build > build-gnu.log 2>&1 || {
         cat build-gnu.log; echo "default GNU build broke after musl build"; exit 1; }
-    echo "DIAG: target/ tree after GNU build:"
-    find target -type f -name staticapp 2>&1
     gnu_binary=$(find target -type d -name x86_64-linux-musl -prune -o -type f -name staticapp -print | head -1)
     [[ -n "$gnu_binary" ]] || { echo "default GNU binary missing"; exit 1; }
 else