fix: refuse a comment on somebody else's pull request, and flag a long reply

The comment that drew the complaint on python/mypy#21967 went out twelve
seconds before our own pull request closed, so a gate keyed on the close
could not have caught it. `handoff` now refuses an issue comment aimed at
a pull request another author opened, in any run state; `--closing-reply`
reaches only the superseding one, after provenance names it. A reply over
120 words gets a length warning in the block. The procedure says which
threads a filed run writes to, and in what order a close is recorded.

Follows #87.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: wolfgang-aura

README.md

@@ -568,9 +568,14 @@ pull request that superseded it with `--superseded-by`, the case is over and
 `handoff` refuses anything aimed at the issue, our pull request or the
 superseding one; `handoff-check` re-reads provenance at publish time, so a case
 that closes after the preview stops there too. One courtesy reply may still go
-out with `--closing-reply`, to one thread, once. On 2026-09-10 python/mypy#21961
-was closed in favour of #21967 and a review-style comment went to #21967 in the
-same minute; its author asked for the activity to stop. See
+out with `--closing-reply`, to one thread, once. Independently of the run's
+state, a comment aimed at a pull request somebody else opened is refused: the
+harness writes to its own issue and its own pull request, nowhere else. A reply
+over 120 words gets a length warning in the block. On 2026-09-10
+python/mypy#21961 was closed in favour of #21967; a 158-word review-style
+comment went to #21967 twelve seconds before the close and a 184-word one to
+#21961, each linking the other, and the author of #21967 asked for the activity
+to stop. See
 [the run record](docs/runs/0010-mypy-21961-superseded.md) and
 [issue #87](https://github.com/wolfgang-aura/Mailman/issues/87).
 

docs/runs/0010-mypy-21961-superseded.md

@@ -20,16 +20,24 @@ on 2026-09-10; #21961 was closed at 20:31 UTC in favour of it.
 
 ## What went wrong, in one minute
 
-At 20:31 UTC, the same minute #21961 closed, a review-style comment drafted
-here was posted on #21967: probe cases, a test-coverage suggestion, a wording
-nit and a cross-link back to #21961. The next morning its author replied
-that the cross-linking and AI-generated follow-ups made the thread harder to
-follow, and that mypy discourages LLM contributions from new contributors.
+Three writes, twelve seconds apart, all drafted here:
 
-Every part of that is fair. The comment was correct and unwanted, which on a
-thread that is now somebody else's is the same as wrong. Nothing in
-`handoff`, `handoff-check` or `provenance --superseded-by` knew that the
-case had closed, so nothing refused it.
+| UTC | Thread | Words | Content |
+| --- | --- | --- | --- |
+| 20:31:12 | #21967, not ours | 158 | review-style comment: probe cases, a test suggestion, a wording nit, a link to #21961 |
+| 20:31:18 | #21961 | 184 | reply to the reviewer, linking #21967 |
+| 20:31:24 | #21961 | | closed by us |
+
+The next morning the author of #21967 replied that the repeated
+cross-linking and AI-generated follow-ups made the thread harder to follow
+than it needed to be, and that mypy discourages LLM contributions from new
+contributors.
+
+Every part of that is fair. The comment on #21967 was correct and unwanted,
+which on a thread that was never ours is the same as wrong. And it went out
+before the close, so a gate keyed on the close alone would not have caught
+it. The write-closed gate below covers the day after; the foreign-thread
+refusal covers the twelve seconds before.
 
 ## What changed
 
@@ -43,6 +51,8 @@ and the superseding pull request are write-closed for the run:
 | `handoff-check` | re-reads provenance and refuses with `run-closed` when the case closed after the preview |
 | `handoff --closing-reply` | allows one courtesy reply to one thread; a second thread refuses with `closing-reply-spent` |
 | `provenance --superseded-by` | prints the rule on stderr at the moment the case is closed |
+| `handoff`, any state | refuses a comment on a pull request somebody else opened; `--closing-reply` reaches only the superseding one, after provenance names it |
+| `handoff`, any state | warns when a reply passes 120 words: that is a review, not a reply |
 
 The operator posted a three-sentence step-back reply on #21967 on 2026-09-11
 and deleted the fork branch. That reply is the run's one closing reply; the
@@ -55,7 +65,10 @@ marker is on disk, and the gate now refuses a second one.
   other people. A correct comment there is still noise.
 - **Do not review the competing pull request.** The comparison belongs in
   our own thread, before the close, or nowhere. Reviewing the winner reads
-  as contesting the close.
+  as contesting the close. This is now refused whatever the run's state.
+- **One thread, one reply, one event.** Two comments in the same minute that
+  link each other are the "repeated cross-linking" the author named. Answer
+  in the thread that asked; let the other thread find it.
 - **The stopping reply is short.** Acknowledge, own the call, step back.
   Three sentences; no explanation of the process, no restated disclosure.
 - **Record it as superseded, not lost.** `--superseded-by` keeps the ledger

mailman/handoff.py

@@ -51,6 +51,12 @@
 
 _KINDS = frozenset({"pull-request", "issue-comment"})
 
+#: Where a follow-up comment stops being a reply and becomes a review. The two
+#: comments that drew the complaint on python/mypy were 158 and 184 words; the
+#: one that answered a maintainer's two questions was 321 and was welcome, so
+#: this warns and does not refuse.
+COMMENT_WORD_LIMIT = 120
+
 # Claims only the person posting can make true. The agent cannot read a diff
 # on the human's behalf, cannot take responsibility, and cannot vouch for the
 # change; a body that says otherwise in the first person is false the moment
@@ -278,6 +284,76 @@ def closed_threads(run_directory: Path, repository: str) -> dict[str, Any]:
     return {"closed": True, "why": why, "threads": threads}
 
 
+def foreign_pull_request(repository: str, number: int) -> str | None:
+    """The author of pull request `number` in `repository`, or None.
+
+    None means "not a pull request", or "GitHub could not be asked". The
+    caller treats the second the same as the first, because the thread it is
+    about to refuse is one it can also name from provenance; this lookup only
+    catches the case provenance has not seen yet.
+    """
+    if shutil.which("gh") is None:
+        return None
+    try:
+        completed = subprocess.run(
+            [
+                "gh",
+                "api",
+                f"repos/{repository_slug(repository)}/pulls/{number}",
+                "--jq",
+                ".user.login",
+            ],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=clamp_timeout_seconds(15),
+            check=False,
+            shell=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if completed.returncode != 0:
+        return None
+    return completed.stdout.strip() or None
+
+
+def foreign_thread_refusal(
+    run_directory: Path,
+    *,
+    repository: str,
+    kind: str,
+    issue_number: int | None,
+    pull_request_lookup: Callable[[str, int], str | None] | None = None,
+) -> str | None:
+    """Why a comment must not go to this thread: it is somebody else's PR.
+
+    The harness reviews its own pull request and answers on its own issue.
+    It has no business on a pull request someone else opened, whatever the
+    state of our run: the comment that drew the complaint on python/mypy#21967
+    went out twelve seconds before our own pull request was closed, when
+    nothing about the case was closed yet.
+    See https://github.com/wolfgang-aura/Mailman/issues/87.
+    """
+    if kind != "issue-comment" or issue_number is None:
+        return None
+    record = load_provenance(run_directory) or {}
+    if issue_number == record.get("pull_request"):
+        return None
+    if issue_number == upstream_issue_number(run_directory, repository):
+        return None
+    lookup = pull_request_lookup or foreign_pull_request
+    author = lookup(repository, issue_number)
+    if author is None:
+        return None
+    return (
+        f"#{issue_number} is a pull request by {author}, not ours. This run "
+        "comments on its own issue and its own pull request; a review of "
+        "somebody else's pull request is not something it sends, and "
+        "--closing-reply does not cover it."
+    )
+
+
 def closure_refusal(
     closure: dict[str, Any], *, kind: str, issue_number: int | None
 ) -> str | None:
@@ -359,6 +435,20 @@ def _preamble(record: dict[str, Any], claims: list[dict[str, Any]]) -> list[str]
                 "",
             ]
         )
+    words = record.get("word_count") or 0
+    if record.get("kind") == "issue-comment" and words > COMMENT_WORD_LIMIT:
+        lines.extend(
+            [
+                "-" * 72,
+                f"LENGTH -- {words} words, and a reply is under {COMMENT_WORD_LIMIT}",
+                "-" * 72,
+                "",
+                "  A follow-up this long reads as a review. Answer what the thread",
+                "  asked and cut the rest; on python/mypy#21967 two comments of",
+                "  158 and 184 words, each linking the other, drew a request to stop.",
+                "",
+            ]
+        )
     warning = record.get("maintainer_edit_warning")
     if warning:
         lines.extend(
@@ -453,11 +543,23 @@ def build_handoff(
     data_root: Path | None = None,
     closing_reply: bool = False,
     owner_type_lookup: Callable[[str], str | None] = github_owner_type,
+    pull_request_lookup: Callable[[str, int], str | None] | None = None,
 ) -> tuple[dict[str, Any], str]:
     """Record the body's digest and render the block that hands it over."""
     closure = closed_threads(run_directory, repository)
     refusal = closure_refusal(closure, kind=kind, issue_number=issue_number)
-    if refusal and not closing_reply:
+    if refusal is None:
+        # Not one of the case's own threads, so the override has no say.
+        foreign = foreign_thread_refusal(
+            run_directory,
+            repository=repository,
+            kind=kind,
+            issue_number=issue_number,
+            pull_request_lookup=pull_request_lookup,
+        )
+        if foreign:
+            raise ValueError(foreign)
+    elif not closing_reply:
         raise ValueError(refusal)
     if closing_reply:
         if refusal is None:
@@ -516,6 +618,7 @@ def build_handoff(
         "digest": body_digest(body),
         "first_person_claims": first_person_claims(body),
         "preservation_claims": preservation_claims(body),
+        "word_count": len(body.split()),
         "head_owner": owner,
         "head_owner_type": owner_type,
         "maintainer_edit_warning": maintainer_edit_warning(owner, owner_type),

mailman/procedure.md

@@ -198,6 +198,12 @@ status check you did not act on is pure cost.
     exact local branch and final body. Run `handoff-check`. Keep all filings
     and upstream writes pending. For a self-sourced defect, prepare any required
     issue text alongside the PR and ask for approval of the ordered filings.
+    After filing, the run writes to two threads only: its own issue and its
+    own pull request. Never a pull request someone else opened. One reply per
+    thread per event, under 120 words unless a maintainer asked questions. If
+    our pull request is closed or overtaken, record `provenance --pr N
+    --superseded-by M` first; after that, `handoff` refuses all three threads
+    and allows one `--closing-reply`. Nothing else goes out.
 16. Refresh the aging evidence for every ready candidate together with
     `mailman hunt refresh HUNT_ID --owner TOKEN` immediately before finishing.
     Duplicate searches and claim reads expire in an hour, and refreshing them

tests/test_handoff.py

@@ -349,6 +349,9 @@ def setUp(self):
         authors = patch("mailman.handoff.check_authorship", return_value={"ok": True, "head": "fixture"})
         authors.start()
         self.addCleanup(authors.stop)
+        foreign = patch("mailman.handoff.foreign_pull_request", return_value=None)
+        foreign.start()
+        self.addCleanup(foreign.stop)
 
     """The push-time half of the duplicate check.
 
@@ -495,6 +498,13 @@ def setUp(self):
         )
         authors.start()
         self.addCleanup(authors.stop)
+        # #21967 is somebody else's pull request; everything else is an issue.
+        foreign = patch(
+            "mailman.handoff.foreign_pull_request",
+            side_effect=lambda _repo, number: "someone" if number == 21967 else None,
+        )
+        foreign.start()
+        self.addCleanup(foreign.stop)
 
     def _comment(self, root: Path, directory: Path, issue: int, **extra):
         body_path = root / "reply.md"
@@ -551,11 +561,41 @@ def test_an_open_run_is_untouched(self) -> None:
         with TemporaryDirectory() as name:
             root = Path(name)
             _, directory = _run_directory(root)
-            record, _ = self._comment(root, directory, 21967)
+            record, _ = self._comment(root, directory, 21960)
             self.assertFalse(record["closure"]["closed"])
+            with self.assertRaises(ValueError):
+                self._comment(root, directory, 21960, closing_reply=True)
+
+    def test_somebody_elses_pull_request_is_refused_while_ours_is_open(self) -> None:
+        # The comment that drew the complaint went out twelve seconds before
+        # our pull request closed. The close is not what makes it wrong.
+        with TemporaryDirectory() as name:
+            root = Path(name)
+            _, directory = _run_directory(root)
+            with self.assertRaises(ValueError) as caught:
+                self._comment(root, directory, 21967)
+            self.assertIn("pull request by someone, not ours", str(caught.exception))
+            # And the override does not reach it until provenance names it.
             with self.assertRaises(ValueError):
                 self._comment(root, directory, 21967, closing_reply=True)
 
+    def test_a_long_reply_is_flagged_as_a_review(self) -> None:
+        with TemporaryDirectory() as name:
+            root = Path(name)
+            _, directory = _run_directory(root)
+            body_path = root / "reply.md"
+            body_path.write_text(("word " * 158).strip(), encoding="utf-8")
+            record, block = build_handoff(
+                run_id=directory.name,
+                run_directory=directory,
+                body_path=body_path,
+                kind="issue-comment",
+                repository="python/mypy",
+                issue_number=21960,
+            )
+            self.assertEqual(record["word_count"], 158)
+            self.assertIn("LENGTH -- 158 words", block)
+
     def test_one_closing_reply_is_allowed_and_a_second_thread_is_not(self) -> None:
         with TemporaryDirectory() as name:
             root = Path(name)
@@ -575,7 +615,7 @@ def test_the_case_closing_after_the_handoff_stops_the_publish(self) -> None:
         with TemporaryDirectory() as name:
             root = Path(name)
             _, directory = _run_directory(root)
-            record, _ = self._comment(root, directory, 21967)
+            record, _ = self._comment(root, directory, 21960)
             self.assertTrue(check_handoff(directory)["ok"])
             _close_the_case(directory)
             result = check_handoff(directory)

tests/test_handoff_gates.py

@@ -131,6 +131,9 @@ def setUp(self):
         authors = patch("mailman.handoff.check_authorship", return_value={"ok": True, "head": "fixture"})
         authors.start()
         self.addCleanup(authors.stop)
+        foreign = patch("mailman.handoff.foreign_pull_request", return_value=None)
+        foreign.start()
+        self.addCleanup(foreign.stop)
 
     def _run(self, root: Path):
         run = RunRecord(