@@ -818,6 +818,40 @@ std::string contract_hash(const std::vector<std::pair<std::string, std::string>>
     return mcpp::toolchain::hash_string(s);
 }
 
+// THE CONTRACT, KEY BY KEY, beside the run record: `contract_hash` keeps one
+// digest, and "the environment contract changed" does not say which variable
+// moved. The record names each key with the digest of its value, and the log
+// names the keys that differ when a run is not replayed.
+std::string contract_keys_path(const fs::path& bdir) {
+    return (bdir / "build.mcpp.ctx").string();
+}
+
+void write_contract_keys(const fs::path& bdir,
+                         const std::vector<std::pair<std::string, std::string>>& e) {
+    std::ofstream os(contract_keys_path(bdir), std::ios::trunc);
+    for (auto const& [k, v] : e) os << k << '\t' << mcpp::toolchain::hash_string(v) << '\n';
+}
+
+std::string changed_contract_keys(const fs::path& bdir,
+                                  const std::vector<std::pair<std::string, std::string>>& e) {
+    std::map<std::string, std::string> before;
+    std::ifstream in(contract_keys_path(bdir));
+    for (std::string line; std::getline(in, line);)
+        if (auto tab = line.find('\t'); tab != std::string::npos)
+            before[line.substr(0, tab)] = line.substr(tab + 1);
+    std::string out;
+    std::set<std::string> seen;
+    for (auto const& [k, v] : e) {
+        seen.insert(k);
+        auto it = before.find(k);
+        if (it == before.end() || it->second != mcpp::toolchain::hash_string(v))
+            out += (out.empty() ? "" : ", ") + k;
+    }
+    for (auto const& [k, h] : before)
+        if (!seen.contains(k)) out += (out.empty() ? "" : ", ") + k;
+    return out;
+}
+
 // The project-relative name of the build output tree ("target" by default), so
 // a glob input never walks into what a previous run produced. Empty when the
 // output lives outside the project, in which case nothing needs excluding.
@@ -1029,6 +1063,9 @@ std::expected<void, std::string> run_build_program_impl(
     fs::path outDir = env.outDir.empty() ? bdir / "out" : env.outDir;
     auto childEnv = contract_env(root, outDir, env);
     std::string ctxHash = contract_hash(childEnv);
+    // What ctxHash is the digest of: the environment and the graph document.
+    auto contractEnv = childEnv;
+    contractEnv.emplace_back("(graph document)", env.graphDigest);
     // THE GRAPH DOCUMENT'S CONTENT, NOT ITS PATH. The path is the same on
     // every run; what the document says is what the program's answer depends
     // on (#647 E1).
@@ -1060,8 +1097,12 @@ std::expected<void, std::string> run_build_program_impl(
     // directives, no run.
     CacheRecord cache = read_cache(bdir);
     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()) {
+        std::string keys;
+        if (stale == "environment contract") keys = changed_contract_keys(bdir, contractEnv);
+        mcpp::log::verbose("build-program", std::format("{}: runs ({}{}{})", who, stale,
+                                                        keys.empty() ? "" : ": ", keys));
+    }
     if (stale.empty()) {
         if (auto terr = dirs::target_directive_error(m, cache.directives); !terr.empty())
             return std::unexpected(terr);
@@ -1303,7 +1344,10 @@ std::expected<void, std::string> run_build_program_impl(
     report_stated_diagnostics(m.package.name, d);
     // A run kept although it asked for a payload (`plan_only`) is never
     // cached: replaying it would keep the build from ever asking again.
-    if (cacheThisRun) write_cache(bdir, root, programHash, compilerHash, ctxHash, d);
+    if (cacheThisRun) {
+        write_cache(bdir, root, programHash, compilerHash, ctxHash, d);
+        write_contract_keys(bdir, contractEnv);
+    }
     return {};
 }
 
 
@@ -1751,10 +1751,6 @@ static std::expected<void, std::string> step6_dependency_build_programs(PrepareS
             // dep build.mcpp sees the SAME active feature set the dep is built
             // with (incl. transitive requests / default-features opt-out).
             auto [req, depDefaultFeatures] = aggregatedRequest(state, i, Instance::Target);
-            auto dirSafe = [](std::string s) {
-                for (auto& c : s) if (c == '/' || c == '\\' || c == ':') c = '_';
-                return s;
-            };
             mcpp::build::BuildProgramEnv bpEnv;
             bpEnv.targetTriple = state.resolvedTargetCanonical;
             // Everything the engine already knows and a build program would
@@ -1791,8 +1787,7 @@ static std::expected<void, std::string> step6_dependency_build_programs(PrepareS
             if (auto dit = state.deviceSourcesByPackage.find(pkg.root.string()); dit != state.deviceSourcesByPackage.end())
                 bpEnv.deviceSources = dit->second;
             bpEnv.features     = feature_closure(pkg.manifest, req, depDefaultFeatures);
-            bpEnv.artifactsDir = state.workRoot / "target" / ".build-mcpp" / "deps"
-                / (dirSafe(pkg.manifest.package.name) + "@" + pkg.manifest.package.version);
+            bpEnv.artifactsDir = build_program_dir(state, i);
             bpEnv.outDir       = state.programOutDir(state.workRoot, pkg.manifest, bpEnv.features);
             bpEnv.genBase      = bpEnv.outDir;
             // mcpp#241: this package's resolved dependencies as
 
@@ -492,6 +492,21 @@ void write_if_changed(const fs::path& file, const std::string& text) {
 // The manifests of one group: the workspace and a member per program.
 std::map<std::string, std::string> resolution_pins(const PrepareState& state);
 
+}  // namespace
+
+std::filesystem::path build_program_dir(const PrepareState& state, std::size_t i) {
+    if (i == 0) return state.workRoot / "target" / ".build-mcpp";
+    auto const& pkg = state.packages[i];
+    if (pkg.selectedMember || (state.isWorkspaceMemberPackage && state.isWorkspaceMemberPackage(i)))
+        return pkg.root / "target" / ".build-mcpp";
+    auto safe = pkg.manifest.package.name;
+    for (auto& c : safe) if (c == '/' || c == '\\' || c == ':') c = '_';
+    return state.workRoot / "target" / ".build-mcpp" / "deps"
+        / (safe + "@" + pkg.manifest.package.version);
+}
+
+namespace {
+
 void write_group(PrepareState& state, const fs::path& dir, const std::vector<Program>& programs,
                  const std::string& standard, const fs::path& enginePackage,
                  const std::string& toolchainSpec) {
@@ -568,9 +583,11 @@ void write_group(PrepareState& state, const fs::path& dir, const std::vector<Pro
         const auto memberDir = dir / p.member;
         fs::path main = p.source.file;
         if (main.empty()) {
-            // Not `build.mcpp` at the member's root: that file would be the
-            // member's OWN build program.
-            main = memberDir / "synthesised.mcpp";
+            // Where it has always been written, beside the package's program
+            // cache: the file a project copies to its root to take it over.
+            main = build_program_dir(state, p.index) / "build.mcpp";
+            std::error_code ec;
+            fs::create_directories(main.parent_path(), ec);
             write_if_changed(main, p.source.synthesised);
         }
         std::string m = std::format(
 
@@ -836,6 +836,11 @@ std::expected<void, std::string> phase4a_graph_load(PrepareState& state);
 std::expected<void, std::string> phase4b_graph_worklist(PrepareState& state);
 // The lookups the later phases ask of the graph (graph_closures.cpp).
 void step4b_define_lookup_closures(PrepareState& state);
+// Where the build program of package `i` keeps its files: its cache, its
+// graph document, and the program mcpp synthesises for it. The root's and a
+// workspace member's are below their own target/; a dependency's is below the
+// build's, by name and version (host_graph.cpp).
+std::filesystem::path build_program_dir(const PrepareState& state, std::size_t i);
 std::expected<void, std::string> phase5_toolchain_after_graph(PrepareState& state);
 std::expected<void, std::string> phase6_features_and_host_tools(PrepareState& state);
 std::expected<void, std::string> phase9_target_side(PrepareState& state);
 
@@ -1625,7 +1625,7 @@ static std::expected<void, std::string> step9_root_build_program(PrepareState& s
         // and may be read-only, and the default would write the compiled
         // helper straight into it. Same value as the default when work_dir is
         // unset, so an ordinary build is unchanged.
-        bpEnv.artifactsDir = state.workRoot / "target" / ".build-mcpp";
+        bpEnv.artifactsDir = build_program_dir(state, 0);
         // Root mode keeps genBase empty: a relative `generated=` from the ROOT
         // package resolves against the package root (the documented contract),
         // not against OUT_DIR.
@@ -2035,7 +2035,7 @@ static std::expected<void, std::string> step9_member_build_programs(PrepareState
         if (auto dit = state.deviceSourcesByPackage.find(pkg.root.string());
             dit != state.deviceSourcesByPackage.end())
             bpEnv.deviceSources = dit->second;
-        bpEnv.artifactsDir = pkg.root / "target" / ".build-mcpp";
+        bpEnv.artifactsDir = build_program_dir(state, i);
         if (i < state.activeFeaturesByPackage.size())
             bpEnv.features = state.activeFeaturesByPackage[i];
         // Beside the cache above, which is in the project under a plan's
 
@@ -33,7 +33,7 @@ rm -f build.mcpp
 "$MCPP" build > b1.log 2>&1 || { cat b1.log; echo "FAIL: leg 1 did not build"; exit 1; }
 grep -q 'Rules.*example.rules.toy' b1.log || {
     cat b1.log; echo "FAIL: leg 1 did not report the rule it applied"; exit 1; }
-find target -name synthesised.mcpp | grep -q . || {
+find target -name build.mcpp | grep -q . || {
     echo "FAIL: leg 1 synthesised no build program"; exit 1; }
 out="$("$MCPP" run 2>&1 | tail -1)"
 [[ "$out" == *"= 42"* ]] || {
 
@@ -55,7 +55,11 @@ assert "app" in sets and sets["app"]["ide"]["configuration"] == "dev", sets.get(
 # B
 unit = next(u for u in sets["app:build"]["translation-units"] if u["source"].endswith("build.mcpp"))
 built = next(e for e in host_cc if e["file"].endswith("build.mcpp"))
-norm = lambda args, wd: [a.replace(wd, "<work>") for a in args]
+def norm(args, wd):
+    # One separator, and the directory above the graph -- the planning
+    # directory of the database, the project of the build -- named alike.
+    root = wd.replace("\\", "/").split("/target/.build-mcpp/host/")[0]
+    return [a.replace("\\", "/").replace(root + "/target/", "<root>/target/") for a in args]
 assert norm(unit["arguments"], unit["work-directory"]) == norm(built["arguments"], built["directory"]), \
     ("B", unit["arguments"], built["arguments"])
 
 
@@ -106,7 +106,8 @@ int main() {
 EOF
 out=$("$MCPP" build 2>&1) || { echo "FAIL: build with build.mcpp: $out"; exit 1; }
 [[ -f helper-ran ]] || { echo "FAIL: build.mcpp did not run: $out"; exit 1; }
-HELPER="target/.build-mcpp/build.mcpp.exe"
+# The program as the build programs' graph linked it (mcpp#797).
+HELPER=$(find target/.build-mcpp/host -path '*/bin/*' -name 'build-program.exe' -type f | head -1)
 [[ -f "$HELPER" ]] || { echo "FAIL: no helper binary at $HELPER"; exit 1; }
 if [[ -x "$OBJDUMP" ]]; then
     h_imports=$("$OBJDUMP" -p "$HELPER" 2>/dev/null | grep -i "DLL Name" || true)
@@ -117,7 +118,7 @@ fi
 HISO="$TMP/hiso"; mkdir -p "$HISO"
 cp "$HELPER" "$HISO/"
 h_rc=0
-(cd "$HISO" && PATH="/usr/bin:/c/Windows/System32" ./build.mcpp.exe >/dev/null 2>&1) || h_rc=$?
+(cd "$HISO" && PATH="/usr/bin:/c/Windows/System32" ./build-program.exe >/dev/null 2>&1) || h_rc=$?
 [[ $h_rc -eq 0 ]] || {
     echo "FAIL: build.mcpp helper does not run without the toolchain bin on PATH (rc=$h_rc)"
     exit 1