@@ -919,37 +919,44 @@ CacheRecord read_cache(const fs::path& bdir) {
     return r;
 }
 
-// Decide whether the cached run is still valid (so we can skip recompiling/running).
-bool cache_fresh(const fs::path& root, const fs::path& bdir, const CacheRecord& c,
-                 const std::string& programHash, const std::string& compilerHash,
-                 const std::string& ctxHash) {
-    if (!c.loaded) return false;
-    if (c.epoch != dirs::kCacheEpoch) return false;  // pre-epoch entries rerun once
-    if (c.unknownRecord) return false;
-    if (c.programHash != programHash) return false;
-    if (c.compilerHash != compilerHash) return false;
-    if (c.ctxHash != ctxHash) return false;   // pre-G3 caches (no ctx line) rerun once
+// Why the cached run is not valid, for the log; empty when it is.
+std::string cache_stale_reason(const fs::path& root, const fs::path& bdir, const CacheRecord& c,
+                               const std::string& programHash, const std::string& compilerHash,
+                               const std::string& ctxHash) {
+    if (!c.loaded) return "no record";
+    if (c.epoch != dirs::kCacheEpoch) return "record epoch";  // pre-epoch entries rerun once
+    if (c.unknownRecord) return "unknown record line";
+    if (c.programHash != programHash) return "program identity " + c.programHash + " -> " + programHash;
+    if (c.compilerHash != compilerHash) return "record shape";
+    if (c.ctxHash != ctxHash) return "environment contract";   // pre-G3 caches rerun once
     for (auto const& [h, path] : c.inputs)
-        if (mcpp::toolchain::hash_file(abs_against_root(root, path)) != h) return false;
+        if (mcpp::toolchain::hash_file(abs_against_root(root, path)) != h) return "input " + path;
     for (auto const& [h, name] : c.envs)
-        if (mcpp::toolchain::hash_string(env_value(name)) != h) return false;
+        if (mcpp::toolchain::hash_string(env_value(name)) != h) return "environment variable " + name;
     // #359: the path SET behind each declared glob. A file appearing or
     // disappearing changes it; editing one does not (that is what the `in`
     // entries above are for).
     if (!c.globs.empty()) {
         auto outName = output_dir_name(root, bdir);
         for (auto const& [h, pattern] : c.globs)
-            if (dirs::glob_fingerprint(root, pattern, outName) != h) return false;
+            if (dirs::glob_fingerprint(root, pattern, outName) != h) return "glob " + pattern;
     }
     // A declared output that vanished invalidates the cache. Driven off the
     // table's mustExistAfterRun so a future output-shaped directive is covered
     // without editing this function.
     for (auto const& def : dirs::kTable) {
         if (!def.mustExistAfterRun) continue;
         for (auto const& p : c.directives.at(def.slot))
-            if (!fs::exists(abs_against_root(root, p))) return false;
+            if (!fs::exists(abs_against_root(root, p))) return "output " + p;
     }
-    return true;
+    return {};
+}
+
+// Decide whether the cached run is still valid (so we can skip recompiling/running).
+bool cache_fresh(const fs::path& root, const fs::path& bdir, const CacheRecord& c,
+                 const std::string& programHash, const std::string& compilerHash,
+                 const std::string& ctxHash) {
+    return cache_stale_reason(root, bdir, c, programHash, compilerHash, ctxHash).empty();
 }
 
 
@@ -1052,7 +1059,10 @@ std::expected<void, std::string> run_build_program_impl(
     // Fast path: declared inputs + contract unchanged → reapply cached
     // directives, no run.
     CacheRecord cache = read_cache(bdir);
-    if (cache_fresh(root, bdir, cache, programHash, compilerHash, ctxHash)) {
+    const auto stale = cache_stale_reason(root, bdir, cache, programHash, compilerHash, ctxHash);
+    if (!stale.empty())
+        mcpp::log::verbose("build-program", std::format("{}: runs ({})", who, stale));
+    if (stale.empty()) {
         if (auto terr = dirs::target_directive_error(m, cache.directives); !terr.empty())
             return std::unexpected(terr);
         // #622 A4. Checked on the cache-hit path too, so a `deploy` a fresh
 
@@ -105,8 +105,17 @@ fs::path root() { return mcpp::home::root() / "engine"; }
 fs::path package_dir() { return root() / std::string(mcpp::MCPP_VERSION) / "modules"; }
 
 bool is_engine_package(const fs::path& dir) {
-    auto rel = dir.lexically_normal().lexically_relative(root().lexically_normal());
-    return !rel.empty() && *rel.begin() != "..";
+    auto inside = [](const fs::path& a, const fs::path& b) {
+        auto rel = a.lexically_normal().lexically_relative(b.lexically_normal());
+        return !rel.empty() && *rel.begin() != "..";
+    };
+    if (inside(dir, root())) return true;
+    // One directory has more than one spelling: `/var` is `/private/var` on
+    // macOS, and Windows has HOME and USERPROFILE, drive-letter case, 8.3 names.
+    std::error_code e1, e2;
+    const auto cd = fs::weakly_canonical(dir, e1);
+    const auto cr = fs::weakly_canonical(root(), e2);
+    return !e1 && !e2 && inside(cd, cr);
 }
 
 std::pair<std::string, std::string> module_texts() {
 
@@ -811,6 +811,10 @@ export struct BuildOverrides {
     // not apply to them.
     std::map<std::string, std::string> resolution_pins;
     bool build_program_graph = false;
+    // The build targets the machine doing it: a sub-build of build programs
+    // or of a host tool. Neither `[build] target` nor the configured default
+    // target applies, since both name the target of the build that asked.
+    bool host_target = false;
     // The project whose `.mcpp/` holds the packages of its custom indices.
     // Empty = the project being built. The build programs' graph names the
     // build that asked, whose indices it shares and whose store already holds
 
@@ -112,6 +112,7 @@ void read_build_programs_marker(BuildOverrides& ov) {
     std::ifstream in(root / ".mcpp-build-programs");
     if (!in) return;
     ov.build_program_graph = true;
+    ov.host_target = true;
     std::string line;
     while (std::getline(in, line)) {
         const auto eq = line.find('=');
 
@@ -1480,6 +1480,7 @@ step6_build_tool(PrepareState& state, HostToolCtx& ctx) {
     sub.work_dir     = mcpp::build::tool_store::scratch_dir(
         ctx.cacheRoot, ctx.entry, state.workRoot);
     sub.target_triple = "";            // HOST — the whole point
+    sub.host_target   = true;
     sub.toolchain     = ctx.toolTcSpec;
     sub.profile       = "release";
     sub.cache_mode    = state.overrides.cache_mode;
 
@@ -652,6 +652,7 @@ build_group(PrepareState& state, const fs::path& dir, const std::vector<Program>
     sub.project_root = dir;
     sub.work_dir     = dir;
     sub.target_triple = "";
+    sub.host_target  = true;
     sub.toolchain    = tc.spec;
     sub.profile      = "build-program";
     sub.cache_mode   = state.overrides.cache_mode;
@@ -711,10 +712,17 @@ build_group(PrepareState& state, const fs::path& dir, const std::vector<Program>
             }
     }
     for (auto const* g : goals)
-        if (!binaries.contains(g->member))
+        if (!binaries.contains(g->member)) {
+            std::string planned;
+            for (auto const& lu : ctx->plan.linkUnits)
+                planned += std::format("{}{}:{}", planned.empty() ? "" : ", ",
+                                       lu.memberOf.empty() ? lu.package : lu.memberOf,
+                                       lu.targetName);
             return std::unexpected(std::format(
-                "the build programs' plan has no program for '{}'{}",
-                qualified(manifest_of(state, g->index)), reproduce()));
+                "the build programs' plan has no program for '{}' (member {}; planned: {}){}",
+                qualified(manifest_of(state, g->index)), g->member,
+                planned.empty() ? std::string("nothing") : planned, reproduce()));
+        }
 
     auto be = mcpp::build::make_ninja_backend();
     mcpp::build::BuildOptions bopt;
 
@@ -1010,12 +1010,13 @@ static std::expected<void, std::string> step1_target_and_static_overrides(Prepar
     // Target-axis default resolution when no --target flag was passed:
     // [build] target (project default, ≙ cargo build.target) >
     // [toolchain] default_target (global config) > host.
-    if (state.overrides.target_triple.empty() && !state.m->buildConfig.target.empty())
+    if (state.overrides.target_triple.empty() && !state.m->buildConfig.target.empty()
+        && !state.overrides.host_target)
         state.overrides.target_triple = state.m->buildConfig.target;
     // Remembered, not requested: this one came out of the global config, so
     // it must not outrank anything the user wrote down (see the pin below).
     bool targetFromGlobalDefault = false;
-    if (state.overrides.target_triple.empty()) {
+    if (state.overrides.target_triple.empty() && !state.overrides.host_target) {
         if (auto cfg = state.get_cfg(true); cfg && !(*cfg)->defaultTarget.empty()) {
             state.overrides.target_triple = (*cfg)->defaultTarget;
             targetFromGlobalDefault = true;
 
@@ -526,9 +526,19 @@ std::expected<void, std::string> step13_windows_resources(PrepareState& state, B
 // Read by W3 (a member's non-public modules).
 std::string workspace_member_of(const PrepareState& state, const std::filesystem::path& root) {
     if (!state.wsManifest || state.runtimeWorkspaceRoot.empty()) return {};
-    const auto rel = root.lexically_normal()
-                         .lexically_relative(state.runtimeWorkspaceRoot.lexically_normal())
-                         .generic_string();
+    auto relative = [](const std::filesystem::path& a, const std::filesystem::path& b) {
+        return a.lexically_normal().lexically_relative(b.lexically_normal()).generic_string();
+    };
+    auto rel = relative(root, state.runtimeWorkspaceRoot);
+    // One directory has more than one spelling (`/var` is `/private/var` on
+    // macOS; a symlinked home; HOME and USERPROFILE on Windows): a member
+    // reached through the other spelling is the same member.
+    if (rel.empty() || rel.starts_with("..")) {
+        std::error_code e1, e2;
+        const auto cr = std::filesystem::weakly_canonical(root, e1);
+        const auto cw = std::filesystem::weakly_canonical(state.runtimeWorkspaceRoot, e2);
+        if (!e1 && !e2) rel = relative(cr, cw);
+    }
     if (rel.empty() || rel == "." || rel.starts_with("..")) return {};
     for (auto const& m : state.wsManifest->workspace.members) {
         if (m == rel) return rel;
 
@@ -36,7 +36,7 @@ out=$("$MCPP" run 2>&1)
 [[ "$out" == *"multi-module build OK"* ]] || { echo "main println missing: $out"; exit 1; }
 
 # Verify build.ninja contents
-build_ninja="$(find target -name build.ninja | head -1)"
+build_ninja="$(find target -name build.ninja -not -path '*/.build-mcpp/*' | head -1)"
 grep -q "gcm.cache/multi.greeter.gcm"  "$build_ninja" || { echo "ninja missing greeter BMI"; exit 1; }
 grep -q "gcm.cache/std.gcm"            "$build_ninja" || { echo "ninja missing std BMI"; exit 1; }
 
 
@@ -45,7 +45,7 @@ AR="${SANDBOX_AR:-ar}"
 "$AR" t "$archive" | grep -q '\.o$' || { echo ".a contains no objects"; exit 1; }
 
 # build.ninja must use cxx_archive rule for the lib target
-ninja_file="$(find target -name build.ninja)"
+ninja_file="$(find target -name build.ninja -not -path '*/.build-mcpp/*')"
 grep -q 'bin/libmathlib.a : cxx_archive' "$ninja_file" || {
     echo "build.ninja did not use cxx_archive for the lib target"; exit 1; }