@@ -549,7 +549,11 @@ The verdict is the exit code; the stamp is bookkeeping the graph needs, and
 mcpp creates it when the command succeeds. Before this, every check needed a
 wrapper script to touch the file — and a command is an argv with no shell
 assumed, so that wrapper could not be written portably at all. A command that
-already writes its own stamp is unaffected: an existing file is left alone.
+writes its own stamp is unaffected: a stamp the command created or rewrote is
+left as it is. A stamp the command did not write is created on the first pass
+and has its modification time moved to the present on every later pass
+(2026.9.27.1+), so after an input changes and the check passes again the stamp
+is newer than that input and the check does not run on the next build.
 
 > A missing stamp does **not** fail the build. ninja leaves the declared output
 > absent and re-runs that edge on every build afterwards, which looks like a
 
@@ -468,7 +468,9 @@ mcpp 为那条边写出 `depfile =` 与 `deps = gcc`，ninja 读取该文件并
 **check 的命令不必自己写 stamp**(mcpp 2026.8.29.1+)。判定是退出码，stamp 是**构建图**
 需要的记账；命令成功时由 mcpp 创建它。在此之前每个 check 都需要一个包装脚本去 touch
 那个文件 —— 而 command 是 argv、不假设有 shell，所以那个包装器**根本没法可移植地写出来**。
-已经自己写 stamp 的命令不受影响：已存在的文件不会被动。
+自己写 stamp 的命令不受影响：命令创建或改写过的 stamp 保持原样。命令没有写的 stamp，
+第一次通过时创建，之后每次通过时把修改时间更新为当前时间(2026.9.27.1+)；因此某个输入
+变化、check 再次通过之后，stamp 比该输入新，下一次构建不再运行这个 check。
 
 > stamp 缺失**不会**让构建失败。ninja 只是留着那个声明的输出不存在，并在之后**每次构建
 > 都重跑**那条边 —— 看起来像一个通过了的检查，实际上它从未被满足。
 
@@ -989,9 +989,19 @@ int run(int argc, char** argv) {
     // platform mcpp runs on, so this needs no shell, no `touch`, and no
     // per-platform spelling.
     //
-    // A command that already creates its stamp is unaffected: existing files
-    // are left alone, so the pre-2026.8.29.1 wrapper scripts keep working
-    // byte-for-byte.
+    // A command that writes its own stamp is unaffected: a stamp the command
+    // created or rewrote is left as the command left it, so the
+    // pre-2026.8.29.1 wrapper scripts keep working byte-for-byte.
+    //
+    // A STAMP THE COMMAND DID NOT WRITE IS TOUCHED, NOT ONLY CREATED. The
+    // stamp is what ninja compares with the inputs, so after an input changes
+    // and the command passes again, its time has to move past that input.
+    // Until 2026.9.27.1 an existing stamp was left alone whatever the command
+    // did, and every check whose command writes nothing -- clang-tidy, an
+    // installer run through `mcpp-deps` -- re-ran on every build after its
+    // first input change, because its output stayed older than the input
+    // forever. The comparison is by the stamp's own time before and after the
+    // command, so a command that did write it is still left alone.
     if (std::string_view(argv[1]) == "__action-stamp") {
         std::vector<std::string> stamps;
         int i = 2;
@@ -1011,19 +1021,39 @@ int run(int argc, char** argv) {
         // `run_exec`: no shell, stdio inherited. The analyser's own output has
         // to reach the terminal unchanged — a check that fails is read by a
         // human, and capturing would either swallow it or reprint it wrapped.
+        // Each stamp's time before the command runs; empty when it is absent.
+        std::vector<std::optional<std::filesystem::file_time_type>> before;
+        for (auto const& s : stamps) {
+            std::error_code ec;
+            const auto p = mcpp::platform::fs::extended_length(std::filesystem::path{s});
+            const auto t = std::filesystem::last_write_time(p, ec);
+            before.push_back(ec ? std::nullopt : std::optional{t});
+        }
         const int r = mcpp::platform::process::run_exec(cmd);
         // The stamps are written ONLY on success. Writing them anyway would
         // make ninja consider the edge satisfied, so the next build would skip
         // a check that had never passed.
         if (r != 0) return r;
-        for (auto const& s : stamps) {
+        for (std::size_t k = 0; k < stamps.size(); ++k) {
+            auto const& s = stamps[k];
             std::error_code ec;
             // Relative to the build directory, which can be deep enough to
             // take the stamp past the Windows path limit (mcpp#641, item 3).
             const auto p = mcpp::platform::fs::extended_length(std::filesystem::path{s});
             if (!p.parent_path().empty())
                 std::filesystem::create_directories(p.parent_path(), ec);
-            if (std::filesystem::exists(p, ec)) continue;
+            if (std::filesystem::exists(p, ec)) {
+                const auto now = std::filesystem::last_write_time(p, ec);
+                // Written by the command during this run: left as it is.
+                if (!ec && (!before[k] || now != *before[k])) continue;
+                std::filesystem::last_write_time(
+                    p, std::filesystem::file_time_type::clock::now(), ec);
+                if (ec) {
+                    std::println(stderr, "error: cannot update check stamp '{}': {}", s, ec.message());
+                    return 1;
+                }
+                continue;
+            }
             std::ofstream out(p, std::ios::trunc);
             if (!out) {
                 std::println(stderr, "error: cannot write check stamp '{}'", s);
 
@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# 780_a_passing_check_moves_its_stamp_past_a_changed_input.sh — a `role =
+# "check"` whose command writes no stamp, after one of its inputs changed.
+#
+# The engine writes such a check's stamp when the command succeeds (313). Until
+# 2026.9.27.1 it only CREATED the stamp: an existing one was left alone. So once
+# an input changed, the check ran and passed, and its stamp stayed older than
+# that input -- and ninja ran it again on every build after, forever. Measured
+# with mcpp-plugins' `deps-cmake`, whose check is a CMake build: every `mcpp
+# build` after one edit re-ran configure, build and install.
+#
+# The criterion is the build AFTER the one that re-ran the check: it must not
+# run the check again. Portable like 313: the command is the engine itself.
+set -e
+
+source "$(dirname "$0")/_host_path.sh"
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+cd "$TMP"
+
+mkdir -p src
+cat > mcpp.toml <<'EOF'
+[package]
+name    = "stampmove"
+version = "0.1.0"
+EOF
+cat > src/main.cpp <<'EOF'
+#include <cstdio>
+int main() { std::printf("STAMP_MOVE_OK\n"); }
+EOF
+echo one > input.txt
+
+MCPP_HOST="$(host_path "$MCPP")"
+INPUT_HOST="$(host_path "$TMP/input.txt")"
+cat > build.mcpp <<EOF
+import std;
+import mcpp;
+int main() {
+    mcpp::action a;
+    a.id          = "probe";
+    a.role        = "check";
+    a.description = "a check whose command writes no stamp";
+    a.arg("$MCPP_HOST").arg("--version")
+     .input("$INPUT_HOST")
+     .output((std::string(mcpp::out_dir()) + "/probe.stamp").c_str())
+     .submit();
+}
+EOF
+
+# `-v` prints each edge ninja runs; the check's is the one that goes through
+# the engine's stamp wrapper.
+ran() { grep -q '__action-stamp' "$1"; }
+
+"$MCPP" build -v > b1.log 2>&1 || { cat b1.log; echo "FAIL: build failed"; exit 1; }
+ran b1.log || { cat b1.log; echo "FAIL: the first build did not run the check"; exit 1; }
+
+"$MCPP" build -v > b2.log 2>&1 || { cat b2.log; echo "FAIL: no-op rebuild failed"; exit 1; }
+if ran b2.log; then cat b2.log; echo "FAIL: the check re-ran with nothing changed"; exit 1; fi
+
+# A changed input: the check runs once...
+sleep 1
+echo two > input.txt
+"$MCPP" build -v > b3.log 2>&1 || { cat b3.log; echo "FAIL: rebuild after the edit failed"; exit 1; }
+ran b3.log || { cat b3.log; echo "FAIL: a changed input did not re-run the check"; exit 1; }
+
+# ...and not again: its stamp is now newer than the input.
+"$MCPP" build -v > b4.log 2>&1 || { cat b4.log; echo "FAIL: rebuild after the check failed"; exit 1; }
+if ran b4.log; then
+    cat b4.log
+    echo "FAIL: the check re-ran on the build after it passed -- its stamp stayed older than the input"
+    exit 1
+fi
+
+out="$("$MCPP" run 2>&1 | tail -1)"
+[[ "$out" == *STAMP_MOVE_OK* ]] || { echo "FAIL: the program did not run: '$out'"; exit 1; }
+echo "OK"