diff --git a/README.md b/README.md
index e3a0c99..5558e95 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,9 @@ changes. The summary line says how many commits the series had before and
 after, and whether its base is the same, a descendant or an ancestor of the
 old one, or diverged from it. A base branch that was itself rewritten, as a
 parent in a stack, is recognized from its force pushes in the repository's
-activity log. Inputs and outputs are described in [action.yml](action.yml).
+activity log. Range-diff comments at least three days old are hidden as
+outdated on the next force push; `hide-after-days` changes or disables that.
+Inputs and outputs are described in [action.yml](action.yml).
 
 `pull_request_target` gives fork PRs a token that can comment. It is safe here
 because nothing from the PR runs: the checkout is the base branch, the action
diff --git a/action.yml b/action.yml
index 0d9d212..c4f126e 100644
--- a/action.yml
+++ b/action.yml
@@ -27,6 +27,9 @@ inputs:
   max-comment-bytes:
     description: "Interdiffs are truncated to keep the comment under this size; GitHub's limit is 65536."
     default: "65000"
+  hide-after-days:
+    description: "On a force push, hide as outdated the earlier range-diff comments that are at least this many days old; empty keeps them all."
+    default: "3"
   post-comment:
     description: Set to `false` to render the comment to the log and job summary without posting it.
     default: "true"
@@ -51,4 +54,5 @@ runs:
         CREATION_FACTOR: ${{ inputs.creation-factor }}
         MAX_COMMENT_BYTES: ${{ inputs.max-comment-bytes }}
         POST_COMMENT: ${{ inputs.post-comment }}
+        HIDE_AFTER_DAYS: ${{ inputs.hide-after-days }}
       run: bash "$GITHUB_ACTION_PATH/post-range-diff-comment.sh"
diff --git a/nix/package.nix b/nix/package.nix
index f97acc1..71b4efa 100644
--- a/nix/package.nix
+++ b/nix/package.nix
@@ -6,6 +6,7 @@
         mkdir -p "$out"
         cp ${../post-range-diff-comment.sh} "$out/post-range-diff-comment.sh"
         cp ${../render.py} "$out/render.py"
+        cp ${../outdated.py} "$out/outdated.py"
       '';
     in
     {
diff --git a/outdated.py b/outdated.py
new file mode 100755
index 0000000..993d09f
--- /dev/null
+++ b/outdated.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Pick the range-diff comments old enough to hide.
+
+Reads one GraphQL comment node per line and prints the ids to minimize.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timedelta, timezone
+
+MARKER = "<!-- post-range-diff-comment "
+
+
+def main(argv: list[str]) -> int:
+    comments = [json.loads(line) for line in sys.stdin if line.strip()]
+    days = float(argv[0])
+    for node_id in outdated(comments, now=datetime.now(timezone.utc), days=days):
+        print(node_id)
+    return 0
+
+
+def outdated(comments: list[dict], *, now: datetime, days: float) -> list[str]:
+    cutoff = now - timedelta(days=days)
+    return [
+        c["id"]
+        for c in comments
+        # Only comments this token wrote, so a person's comment is never hidden.
+        if c["viewerDidAuthor"]
+        and c["body"].startswith(MARKER)
+        and not c["isMinimized"]
+        and datetime.fromisoformat(c["createdAt"].replace("Z", "+00:00")) <= cutoff
+    ]
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/post-range-diff-comment.sh b/post-range-diff-comment.sh
index 22b9449..e47cfaf 100755
--- a/post-range-diff-comment.sh
+++ b/post-range-diff-comment.sh
@@ -10,6 +10,7 @@
 #   CREATION_FACTOR    optional, passed to --creation-factor
 #   MAX_COMMENT_BYTES  cap on the comment body
 #   POST_COMMENT       "false" to render without posting
+#   HIDE_AFTER_DAYS    hide earlier range-diff comments at least this old
 set -euo pipefail
 
 : "${BEFORE:?}" "${AFTER:?}" "${BASE_REF:?}" "${PR_NUMBER:?}"
@@ -110,11 +111,45 @@ if [[ ${POST_COMMENT:-true} == false ]]; then
 fi
 
 : "${GH_TOKEN:?}"
-if ! url="$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" \
-  -F body=@"$WORK/comment.md" --jq .html_url)"; then
+hide_outdated() {
+  local ids id
+  # shellcheck disable=SC2016
+  ids="$(gh api graphql --paginate \
+    -f owner="${REPO%/*}" -f name="${REPO#*/}" -F number="$PR_NUMBER" -f query='
+      query($owner: String!, $name: String!, $number: Int!, $endCursor: String) {
+        repository(owner: $owner, name: $name) {
+          pullRequest(number: $number) {
+            comments(first: 100, after: $endCursor) {
+              pageInfo { hasNextPage endCursor }
+              nodes { id body createdAt isMinimized viewerDidAuthor }
+            }
+          }
+        }
+      }' --jq '.data.repository.pullRequest.comments.nodes[]' |
+    python3 "$HERE/outdated.py" "$HIDE_AFTER_DAYS")" || return
+  for id in $ids; do
+    [[ $id == "$1" ]] && continue
+    # shellcheck disable=SC2016
+    gh api graphql -f id="$id" -f query='
+      mutation($id: ID!) {
+        minimizeComment(input: {subjectId: $id, classifier: OUTDATED}) {
+          clientMutationId
+        }
+      }' >/dev/null || return
+  done
+}
+
+if ! posted="$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" \
+  -F body=@"$WORK/comment.md" --jq '"\(.node_id) \(.html_url)"')"; then
   echo "::error::could not post the comment; the token needs pull-requests: write" \
     "(pull_request events from forks only get a read-only token)"
   exit 1
 fi
+read -r node_id url <<<"$posted"
 echo "comment-url=$url" >>"$OUT"
 echo "posted $url"
+
+# After posting, so a failed post never leaves the old ones hidden.
+if [[ -n ${HIDE_AFTER_DAYS:-} ]] && ! hide_outdated "$node_id"; then
+  echo "::warning::could not hide the outdated range-diff comments"
+fi
diff --git a/tests/test_action.py b/tests/test_action.py
index 9030ad6..9a4313c 100644
--- a/tests/test_action.py
+++ b/tests/test_action.py
@@ -1,11 +1,15 @@
+import json
 import os
 import pathlib
 import subprocess
 import tempfile
 import unittest
 
+from test_outdated import comment
+
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 PACKAGE = os.environ.get("POST_RANGE_DIFF_EXECUTABLE")
+COMMENT_URL = "https://github.com/test/repo/pull/1#issuecomment-1"
 
 
 class ActionTest(unittest.TestCase):
@@ -49,13 +53,28 @@ def run_action(
         forced=True,
         base_ref="main",
         rewound=(),
+        comments=None,
+        post_fails=False,
     ):
-        # Stands in for the activity log: prints the old tips of the base branch.
+        # Stands in for GitHub: the old tips of the base branch, the comments
+        # of the pull request, and a record of the ones it was asked to hide.
         stub = self.root / "stub"
         stub.mkdir()
+        (stub / "comments").write_text(
+            "".join(json.dumps(c) + "\n" for c in comments or ())
+        )
+        post = "exit 1" if post_fails else f"echo NEW {COMMENT_URL}"
         gh = stub / "gh"
-        gh.write_text("#!/bin/sh\n" + "".join(f"echo {tip}\n" for tip in rewound))
+        gh.write_text(f"""#!/bin/sh
+case "$*" in
+*minimizeComment*) echo "$*" >>"{stub}/hidden" ;;
+*graphql*) cat "{stub}/comments" ;;
+*/activity*) printf '%s\\n' {" ".join(rewound)} ;;
+*) {post} ;;
+esac
+""")
         gh.chmod(0o755)
+        posting = comments is not None
         checkout = self.root / "checkout"
         self.git(
             "clone",
@@ -77,7 +96,9 @@ def run_action(
             GITHUB_SERVER_URL="https://github.com",
             GITHUB_OUTPUT=str(output),
             GITHUB_STEP_SUMMARY=str(summary),
-            POST_COMMENT="false",
+            POST_COMMENT=str(posting).lower(),
+            GH_TOKEN="token",
+            HIDE_AFTER_DAYS="3",
             PATH=f"{stub}{os.pathsep}{os.environ['PATH']}",
         )
         command = (
@@ -94,16 +115,17 @@ def run_action(
             timeout=20,
             check=False,
         )
-        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.returncode, int(post_fails), result.stderr)
         self.assertTrue(output.exists(), result.stderr)
-        self.assertEqual(output.read_text(), f"forced={str(forced).lower()}\n")
-        if forced:
+        posted = f"comment-url={COMMENT_URL}\n" if posting and not post_fails else ""
+        self.assertEqual(output.read_text(), f"forced={str(forced).lower()}\n{posted}")
+        if not forced:
+            self.assertFalse(summary.exists())
+        elif not posting:
             self.assertIn("<b>range-diff</b>", result.stdout)
             self.assertIn(self.before, result.stdout)
             self.assertIn(self.after, result.stdout)
             self.assertTrue(result.stdout.endswith(summary.read_text()))
-        else:
-            self.assertFalse(summary.exists())
         return result.stdout
 
     def test_force_push_full_checkout(self):
@@ -150,6 +172,23 @@ def test_series_an_old_base_tip_contained(self):
         self.after = self.commit("child again\n", "child", amend=True, path="child")
         self.run_action(base_ref="topic", rewound=[self.before])
 
+    def test_old_range_diff_comments_are_hidden(self):
+        old = comment("OLD", "2000-01-01T00:00:00Z")
+        new = comment("NEW", "2999-01-01T00:00:00Z")
+        self.run_action(comments=[old, new])
+        hidden = (self.root / "stub" / "hidden").read_text()
+        self.assertIn("id=OLD", hidden)
+        self.assertNotIn("id=NEW", hidden)
+
+    def test_the_posted_comment_is_never_hidden(self):
+        self.run_action(comments=[comment("NEW", "2000-01-01T00:00:00Z")])
+        self.assertFalse((self.root / "stub" / "hidden").exists())
+
+    def test_a_failed_post_hides_nothing(self):
+        old = comment("OLD", "2000-01-01T00:00:00Z")
+        self.run_action(comments=[old], post_fails=True)
+        self.assertFalse((self.root / "stub" / "hidden").exists())
+
     def test_force_push_shallow_checkout(self):
         self.run_action(shallow=True)
 
diff --git a/tests/test_outdated.py b/tests/test_outdated.py
new file mode 100644
index 0000000..8418a0b
--- /dev/null
+++ b/tests/test_outdated.py
@@ -0,0 +1,45 @@
+import pathlib
+import sys
+import unittest
+from datetime import datetime, timezone
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
+import outdated
+
+NOW = datetime(2026, 10, 8, 12, tzinfo=timezone.utc)
+
+
+def comment(node_id, created, **changed):
+    return {
+        "id": node_id,
+        "createdAt": created,
+        "isMinimized": False,
+        "viewerDidAuthor": True,
+        "body": outdated.MARKER + "before=a after=b -->\n<details>",
+    } | changed
+
+
+class OutdatedTest(unittest.TestCase):
+    def pick(self, *comments):
+        return outdated.outdated(list(comments), now=NOW, days=3)
+
+    def test_age(self):
+        picked = self.pick(
+            comment("old", "2026-10-01T00:00:00Z"),
+            comment("just old enough", "2026-10-05T12:00:00Z"),
+            comment("recent", "2026-10-05T12:00:01Z"),
+        )
+        self.assertEqual(picked, ["old", "just old enough"])
+
+    def test_only_its_own_visible_range_diffs(self):
+        old = "2026-10-01T00:00:00Z"
+        picked = self.pick(
+            comment("someone else's", old, viewerDidAuthor=False),
+            comment("another comment", old, body="looks good"),
+            comment("already hidden", old, isMinimized=True),
+        )
+        self.assertEqual(picked, [])
+
+
+if __name__ == "__main__":
+    unittest.main()