interp-engine 1.3.0__tar.gz → 1.3.2__tar.gz

{interp_engine-1.3.0 → interp_engine-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interp-engine
-Version: 1.3.0
+Version: 1.3.2
 Summary: A fast, standardized interpretability engine that supports most modern models and architectures. Powers Neuronpedia.
 Project-URL: Homepage, https://github.com/decoderesearch/interp-engine
 Project-URL: Repository, https://github.com/decoderesearch/interp-engine
@@ -44,7 +44,6 @@ Description-Content-Type: text/markdown
   <a href="https://join.slack.com/t/opensourcemechanistic/shared_invite/zt-3z9o0hxjl-MDX9pbATO2qESOazNDLpdQ"><img src="https://img.shields.io/badge/Slack-Open%20Source%20Mechanistic%20Interpretability-4A154B?logo=slack&logoColor=white" alt="Join the Slack"></a>
 </p>
 
-
 `interp-engine` is an interpretability engine that is fast (>40x tok/s vs HF eager), standardized (34 'points'/addresses across architectures), and easy to use and debug. It powers all of [Neuronpedia](https://neuronpedia.org)'s inference and is checked for accuracy against HF Transformers and other engines.
 
 <p align="center">
@@ -98,7 +97,7 @@ Add "use interp-engine" to your prompt and let your agent figure it out - everyt
 
 ## Performance / Speed
 
-vLLM gives `interp-engine` high throughput via concurrency, and `backend="vllm-static"` adds CUDA-graph replay on top of that *without giving up capture or steering*. Every column below is capture-capable.
+vLLM gives `interp-engine` high throughput via concurrency, and `backend="vllm-static"` gives even higher throughput at the cost of higher VRAM usage. Every column below is capture-capable.
 
 <!-- THROUGHPUT:START -->
 
@@ -137,9 +136,7 @@ We verify correctness in two main ways:
 1. A test suite that checks results across several models - what each check is designed to catch is in [INTERNALS.md](docs/INTERNALS.md#correctness).
 2. A full `validator` comparison engine that checks most hook points across 50+ models, at early, middle and late layers - fully reproducible, with detailed results saved in the git repo at [`validator/`](validator/).
 
-## Why use an Interpretability Engine, instead of just having my AI code whatever it needs on the fly?
-
-Software is easy to make in 2026, here's why an engine makes sense:
+## Why use an Interpretability Engine instead of building from scratch?
 
 1. **Speed**: Get performance without sacrificing correctness.
 2. **Standardization + Verification**: Eliminate ambiguity when referring to points, plus a full test suite included.

{interp_engine-1.3.0 → interp_engine-1.3.2}/README.md

@@ -13,7 +13,6 @@
   <a href="https://join.slack.com/t/opensourcemechanistic/shared_invite/zt-3z9o0hxjl-MDX9pbATO2qESOazNDLpdQ"><img src="https://img.shields.io/badge/Slack-Open%20Source%20Mechanistic%20Interpretability-4A154B?logo=slack&logoColor=white" alt="Join the Slack"></a>
 </p>
 
-
 `interp-engine` is an interpretability engine that is fast (>40x tok/s vs HF eager), standardized (34 'points'/addresses across architectures), and easy to use and debug. It powers all of [Neuronpedia](https://neuronpedia.org)'s inference and is checked for accuracy against HF Transformers and other engines.
 
 <p align="center">
@@ -67,7 +66,7 @@ Add "use interp-engine" to your prompt and let your agent figure it out - everyt
 
 ## Performance / Speed
 
-vLLM gives `interp-engine` high throughput via concurrency, and `backend="vllm-static"` adds CUDA-graph replay on top of that *without giving up capture or steering*. Every column below is capture-capable.
+vLLM gives `interp-engine` high throughput via concurrency, and `backend="vllm-static"` gives even higher throughput at the cost of higher VRAM usage. Every column below is capture-capable.
 
 <!-- THROUGHPUT:START -->
 
@@ -106,9 +105,7 @@ We verify correctness in two main ways:
 1. A test suite that checks results across several models - what each check is designed to catch is in [INTERNALS.md](docs/INTERNALS.md#correctness).
 2. A full `validator` comparison engine that checks most hook points across 50+ models, at early, middle and late layers - fully reproducible, with detailed results saved in the git repo at [`validator/`](validator/).
 
-## Why use an Interpretability Engine, instead of just having my AI code whatever it needs on the fly?
-
-Software is easy to make in 2026, here's why an engine makes sense:
+## Why use an Interpretability Engine instead of building from scratch?
 
 1. **Speed**: Get performance without sacrificing correctness.
 2. **Standardization + Verification**: Eliminate ambiguity when referring to points, plus a full test suite included.

{interp_engine-1.3.0 → interp_engine-1.3.2}/interp_engine/chat_formatters.py

@@ -188,6 +188,7 @@ class DeepseekV4Formatter:
         prefix = self._bos + "".join(blocks[: len(lead)])
         blocks = blocks[len(lead) :]
 
+        self._reassign_interior_openers(blocks, turns)
         scaffold = self._split_scaffold(blocks, turns)
         return RenderedChat(prefix=prefix, blocks=tuple(blocks), suffix=scaffold if add_generation_prompt else "")
 
@@ -270,6 +271,32 @@ class DeepseekV4Formatter:
             turn.setdefault(self._reasoning_key, value)
         return turn
 
+    def _reassign_interior_openers(self, blocks: list[str], turns: Sequence[Message]) -> None:
+        """Move each assistant opener onto the assistant turn it opens, in place.
+
+        The encoder writes ``<｜Assistant｜>`` plus a thinking delimiter at the *tail* of every
+        user/developer turn -- including interior ones that a completed assistant answer follows,
+        not just the last turn whose opener is the generation scaffold. Because ``_tails``
+        decomposes the render by common suffix, that opener lands at the end of the *user* block,
+        so span metadata attributes it to the user turn: the opener renders inside the user's
+        bubble and the assistant's bubble starts on bare content. This peels it off the user turn
+        and prepends it to the assistant turn it belongs to, leaving ``RenderedChat.text``
+        unchanged (a substring only moves across the block boundary). The final turn's opener has
+        no assistant turn after it and is handled by :meth:`_split_scaffold` instead.
+        """
+        for k in range(len(blocks) - 1):
+            turn = turns[k]
+            if turn.get("role") not in ("user", "developer") or turn.get("task") is not None:
+                continue
+            if turns[k + 1].get("role") != "assistant":
+                continue
+            for delimiter in (self._think_open, self._think_close):
+                opener = self._assistant_token + delimiter
+                if blocks[k].endswith(opener):
+                    blocks[k] = blocks[k][: -len(opener)]
+                    blocks[k + 1] = opener + blocks[k + 1]
+                    break
+
     def _split_scaffold(self, blocks: list[str], turns: Sequence[Message]) -> str:
         """Remove and return the trailing generation scaffold from ``blocks``, or ``""``.
 

{interp_engine-1.3.0 → interp_engine-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "interp-engine"
-version = "1.3.0"
+version = "1.3.2"
 description = "A fast, standardized interpretability engine that supports most modern models and architectures. Powers Neuronpedia."
 readme = "README.md"
 license = "Apache-2.0"

{interp_engine-1.3.0 → interp_engine-1.3.2}/tests/test_chat_formatters.py

@@ -66,9 +66,12 @@ def _stub_encoder(reasoning_key: str = "reasoning_content") -> ModuleType:
     """A module with the surface :class:`DeepseekV4Formatter` reads, and the same semantics.
 
     Not a second implementation of the format -- it renders a deliberately simplified one. What
-    it reproduces faithfully is the three behaviours the formatter has to work around: the
-    trailing ``<｜Assistant｜>`` scaffold appears whether or not you asked for it, ``wo_eos``
-    is how a turn is held open, and ``context`` decomposes the render per message.
+    it reproduces faithfully is the four behaviours the formatter has to work around: the
+    trailing ``<｜Assistant｜>`` scaffold appears whether or not you asked for it (and rides on
+    the user turn it follows, not the assistant turn it opens), ``wo_eos`` is how a turn is held
+    open, ``context`` decomposes the render per message, and ``drop_thinking`` strips a completed
+    answer's reasoning once a later user turn demotes it to history -- the non-monotonic rewrite
+    this whole module exists for.
     """
     module = ModuleType("stub_dsv4_encoder")
     module.bos_token = BOS  # type: ignore[attr-defined]
@@ -78,39 +81,53 @@ def _stub_encoder(reasoning_key: str = "reasoning_content") -> ModuleType:
     module.thinking_end_token = THINK_CLOSE  # type: ignore[attr-defined]
     module.thinking_template = "{" + reasoning_key + "}"  # type: ignore[attr-defined]
 
-    def render_one(index: int, messages: Sequence[dict], thinking_mode: str) -> str:
+    def last_user_index(messages: Sequence[dict]) -> int:
+        for idx in range(len(messages) - 1, -1, -1):
+            if messages[idx].get("role") in ("user", "developer"):
+                return idx
+        return -1
+
+    def render_one(index: int, messages: Sequence[dict], thinking_mode: str, drop_thinking: bool) -> str:
         message = messages[index]
         role = message.get("role")
+        last_user = last_user_index(messages)
         text = ""
         if role == "user":
             text += USER + (message.get("content") or "")
         elif role == "assistant":
-            if thinking_mode == "thinking":
+            # Reasoning survives only for the turn being generated (after the last user turn) or
+            # when dropping is off -- the encoder's `drop_thinking`, which makes the render
+            # non-monotonic because a completed answer's block shrinks once a later user turn
+            # demotes it to history.
+            if thinking_mode == "thinking" and (not drop_thinking or index > last_user):
                 text += (message.get(reasoning_key) or "") + THINK_CLOSE
             text += message.get("content") or ""
             if not message.get("wo_eos", False):
                 text += EOS
         else:
             text += message.get("content") or ""
-        if role == "user" and index == len(messages) - 1:
-            text += ASSISTANT + (THINK_OPEN if thinking_mode == "thinking" else THINK_CLOSE)
-        elif role == "user":
-            text += ASSISTANT + THINK_CLOSE
+        # The assistant opener rides on the user/developer turn it follows (or on the last turn,
+        # as the generation scaffold), never on the assistant turn itself.
+        is_last = index == len(messages) - 1
+        next_is_assistant = not is_last and messages[index + 1].get("role") == "assistant"
+        if role in ("user", "developer") and (is_last or next_is_assistant):
+            opens_thinking = thinking_mode == "thinking" and (not drop_thinking or index >= last_user)
+            text += ASSISTANT + (THINK_OPEN if opens_thinking else THINK_CLOSE)
         return text
 
     def encode_messages(
         messages: Sequence[dict],
         thinking_mode: str,
         context: Sequence[dict] | None = None,
-        drop_thinking: bool = True,  # noqa: ARG001 - part of the signature under test
+        drop_thinking: bool = True,
         add_default_bos_token: bool = True,
-        reasoning_effort: str | None = None,  # noqa: ARG001 - ditto
+        reasoning_effort: str | None = None,  # noqa: ARG001 - part of the signature under test
     ) -> str:
         context = list(context or [])
         full = context + list(messages)
         prompt = BOS if add_default_bos_token and not context else ""
         for offset in range(len(messages)):
-            prompt += render_one(len(context) + offset, full, thinking_mode)
+            prompt += render_one(len(context) + offset, full, thinking_mode, drop_thinking)
         return prompt
 
     module.encode_messages = encode_messages  # type: ignore[attr-defined]
@@ -255,6 +272,30 @@ def test_continue_final_message_refuses_a_non_assistant_turn(formatter: Deepseek
         formatter.render(CHAT, continue_final_message=True)
 
 
+def test_interior_assistant_opener_rides_on_its_own_block(formatter: DeepseekV4Formatter):
+    """A completed answer's ``<｜Assistant｜>`` opener belongs to the assistant, not the user.
+
+    The encoder writes the opener at the *tail* of the user turn it follows, so the raw block
+    split leaves it on the user turn. Left there it renders inside the previous user's bubble,
+    and a follow-up message makes the whole assistant scaffold appear to jump backwards a turn.
+    The blocks must instead read as one clean turn each.
+    """
+    conversation = [
+        {"role": "user", "content": "hi"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "hi 2"},
+    ]
+    rendered = formatter.render(conversation, add_generation_prompt=True, enable_thinking=False)
+    assert rendered.blocks == (
+        USER + "hi",
+        ASSISTANT + THINK_CLOSE + "Hi there!" + EOS,
+        USER + "hi 2",
+    )
+    assert rendered.suffix == ASSISTANT + THINK_CLOSE
+    # The move only relocates a substring across a boundary; the prompt itself is unchanged.
+    assert rendered.text == formatter.render(conversation, add_generation_prompt=True, enable_thinking=False).text
+
+
 def test_closed_assistant_turn_gets_no_invented_scaffold(formatter: DeepseekV4Formatter):
     """A Jinja template would open a fresh turn here; this format does not, and we follow it.
 
@@ -385,6 +426,26 @@ def test_generation_scaffold_opens_the_assistant_turn(tok: Tokenize):
     assert all(s.role == "assistant" and s.section == "header" for s in trailing)
 
 
+def test_completed_assistant_opener_is_the_assistants_header_not_the_users_footer(tok: Tokenize):
+    """The span-level regression behind the reported bug.
+
+    On a follow-up turn the previous assistant's ``<｜Assistant｜></think>`` scaffold was landing
+    in the earlier user bubble (span metadata attributed it to the user's message), so the user
+    turn grew an assistant footer and the assistant turn lost its header. Each opener must be the
+    header of the assistant turn it introduces.
+    """
+    conversation = [
+        {"role": "user", "content": "hi"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "hi 2"},
+    ]
+    spans = tok.message_spans(conversation, add_generation_prompt=True, enable_thinking=False)
+    user0 = "".join(s.token_str for s in spans if s.message_index == 0)
+    assistant1_header = "".join(s.token_str for s in spans if s.message_index == 1 and s.section == "header")
+    assert ASSISTANT not in user0, "the assistant opener leaked into the user's bubble"
+    assert assistant1_header == ASSISTANT + THINK_CLOSE
+
+
 def test_prefill_spans_end_on_content(tok: Tokenize):
     """A held-open turn has no footer to find: generation continues from its last token."""
     prefill = [*CHAT, {"role": "assistant", "content": "It is "}]
@@ -398,7 +459,9 @@ def test_prefill_spans_end_on_content(tok: Tokenize):
 # --------------------------------------------------------------------------- #
 
 
-def _legacy_partition(tok: Tokenize, messages: list[dict[str, str]]) -> tuple[list[int], list[tuple[int, int]]]:
+def _legacy_partition(
+    tok: Tokenize, messages: list[dict[str, str]], **template_kwargs: Any
+) -> tuple[list[int], list[tuple[int, int]]]:
     """The prefix-delta arithmetic that callers ran inline before ``message_partition``.
 
     Kept here verbatim as the reference implementation. A template-rendered model has to
@@ -409,7 +472,9 @@ def _legacy_partition(tok: Tokenize, messages: list[dict[str, str]]) -> tuple[li
     previous = 0
     full_ids: list[int] = []
     for index in range(len(messages)):
-        current = tok.apply_chat_template(messages[: index + 1], tokenize=True, add_generation_prompt=False)
+        current = tok.apply_chat_template(
+            messages[: index + 1], tokenize=True, add_generation_prompt=False, **template_kwargs
+        )
         assert isinstance(current, list)
         spans.append((previous, len(current)))
         previous = len(current)
@@ -507,11 +572,15 @@ def test_the_legacy_arithmetic_would_misplace_a_code_rendered_conversation(tok:
     """Why this method exists rather than the caller keeping its inline loop.
 
     The prefix delta assumes appending a message only appends tokens. DeepSeek-V4 rewrites
-    earlier turns once a later user turn exists (a turn stops being the *last* user turn), so
-    the deltas land in the wrong places — and the failure is silent, since they still look like
-    a partition.
+    earlier turns once a later user turn exists (``drop_thinking`` strips a completed answer's
+    reasoning once it stops being the current turn), so the deltas land in the wrong places — and
+    the failure is silent, since they still look like a partition. This only bites in thinking
+    mode, where there is reasoning to drop; in chat mode the render is monotonic and the two
+    agree.
     """
-    assert tok.message_partition(MULTI_TURN) != _legacy_partition(tok, MULTI_TURN)
+    assert tok.message_partition(MULTI_TURN, enable_thinking=True) != _legacy_partition(
+        tok, MULTI_TURN, enable_thinking=True
+    )
 
 
 # --------------------------------------------------------------------------- #

{interp_engine-1.3.0 → interp_engine-1.3.2}/tests/test_doc_code_fences.py

@@ -48,6 +48,12 @@ DOC_FILES = (
     "benchmarks/README.md",
 )
 
+#: The samples site, which is nothing *but* fences a reader pastes -- so it is the doc that rot
+#: hurts most. Globbed rather than listed: a page there is one file with one job, and adding one
+#: should not need an edit here. Its own build would not catch a rename, since it never imports
+#: the package.
+SAMPLE_DOCS = tuple(sorted(str(p.relative_to(ROOT)) for p in (ROOT / "visualizer-web/docs-site/docs").glob("*.md")))
+
 #: Submodules the docs may import from directly. The package's own ``__init__`` says these two are
 #: reachable-but-not-re-exported on purpose (the worker RPC names, and the payload codecs), so a doc
 #: that shows tier-1 integration has to name them.
@@ -85,7 +91,7 @@ def _engine_imports(tree: ast.Module) -> list[tuple[str, str]]:
 
 DOC_FENCES = [
     pytest.param(path, line, source, id=f"{path}:{line}")
-    for path in DOC_FILES
+    for path in DOC_FILES + SAMPLE_DOCS
     for line, source in _fences((ROOT / path).read_text())
 ]
 
@@ -98,6 +104,11 @@ def test_the_doc_list_still_matches_the_docs_on_disk():
         assert (ROOT / path).exists(), f"{path} is listed here but does not exist"
 
 
+def test_the_samples_site_was_found():
+    """The glob above is silent when the directory moves, which would drop every sample page."""
+    assert len(SAMPLE_DOCS) > 5, f"only {len(SAMPLE_DOCS)} sample pages found; did docs-site move?"
+
+
 def test_there_are_fences_to_check():
     """Guards against the regex silently matching nothing after a format change."""
     assert len(DOC_FENCES) > 15, f"only {len(DOC_FENCES)} python fences found; did the fence format change?"

{interp_engine-1.3.0 → interp_engine-1.3.2}/tests/test_points_registry.py

@@ -32,6 +32,11 @@ from interp_engine.vllm_capture.requests import _DEMUX_MHC_HOOKS, _DEMUX_OUT_HOO
 ROOT = pathlib.Path(__file__).resolve().parent.parent
 DOCS = ROOT / "docs"
 
+#: The samples site's vocabulary page. Outside ``docs/``, so nothing else in this file reaches it,
+#: and it tables every point by name -- the one list a reader consults to find out what may be asked
+#: for at all.
+ADDRESSES_PAGE = ROOT / "visualizer-web/docs-site/docs/addresses.md"
+
 #: How the support table in ``docs/SUPPORTED_POINTS.md`` spells each :class:`points.VllmSupport`.
 _SUPPORT_MARKS = {
     "✅": points.VllmSupport.HOOKS,
@@ -50,6 +55,9 @@ _PROSE_COUNTS = (
     ("docs/SUPPORTED_POINTS.md", r"The (\d+) canonical points", "declared"),
     ("docs/SUPPORTED_POINTS.md", r"vLLM backend serves (\d+) of them", "served"),
     ("docs/SUPPORTED_POINTS.md", r"(\d+) of those by recompute", "recomputed"),
+    ("visualizer-web/docs-site/docs/addresses.md", r"The (\d+) points", "declared"),
+    ("visualizer-web/docs-site/docs/addresses.md", r"(\d+) on every model", "global"),
+    ("visualizer-web/docs-site/docs/addresses.md", r"(\d+) more that need a hyper-connection trunk", "conditional"),
 )
 
 
@@ -313,12 +321,32 @@ def test_the_support_table_doc_says_what_the_point_table_declares():
     )
 
 
+def test_the_samples_page_names_every_point_and_no_others():
+    """``addresses.md``'s two tables, checked against the registry they transcribe.
+
+    It carries no support column -- that claim is SUPPORTED_POINTS.md's, and checked above -- so
+    this is the narrower assertion that the names are the point set. A point added without a row
+    here is one the samples site tells a reader does not exist, which is the same silent failure
+    as a point missing from any other consumer.
+    """
+    rows = re.findall(r"^\|([^|]*`\w+`[^|]*)\|", ADDRESSES_PAGE.read_text(), re.MULTILINE)
+    assert len(rows) > 20, f"the table parse found only {len(rows)} rows; did the page's format change?"
+
+    listed = {name for row in rows for name in re.findall(r"`(\w+)`", row)}
+    every = {p.name for p in (*points.POINTS, *points.HYPER_CONNECTION_POINTS)}
+    assert listed == every, (
+        f"missing from addresses.md: {sorted(every - listed)}; no longer a point: {sorted(listed - every)}"
+    )
+
+
 @pytest.mark.parametrize(("doc", "pattern", "which"), _PROSE_COUNTS)
 def test_a_point_count_stated_in_prose_matches_the_registry(doc: str, pattern: str, which: str):
     """A sentence saying "34 standardized points" is a claim the table beside it does not keep honest."""
     every = (*points.POINTS, *points.HYPER_CONNECTION_POINTS)
     expected = {
         "declared": len(every),
+        "global": len(points.POINTS),
+        "conditional": len(points.HYPER_CONNECTION_POINTS),
         "served": sum(p.vllm is not points.VllmSupport.NONE for p in every),
         "recomputed": sum(p.vllm is points.VllmSupport.RECOMPUTE for p in every),
     }[which]

{interp_engine-1.3.0 → interp_engine-1.3.2}/tests/test_release.py

@@ -136,6 +136,56 @@ class TestWhichVersionWins:
         assert release.version_key("v1.2.3") is None
 
 
+class TestWhetherAChangeIsWorthAVersion:
+    """A version is what a downstream pin moves to, so only the imported engine earns one.
+
+    Two exclusions with different reasons: `visualizer-web/` and the validator never reach a user,
+    while `tests/`, `docs/`, `benchmarks/` and the README do reach one and still cannot change what
+    `import interp_engine` gives them.
+    """
+
+    PREFIXES = ["interp_engine", "tests", "docs", "benchmarks", "README.md", "pyproject.toml"]
+
+    def test_the_engine_and_its_dependency_set_are_worth_a_version(self):
+        assert release.changes_the_package("interp_engine/points.py", self.PREFIXES)
+        # The dependency table is part of what an install resolves, so pyproject counts.
+        assert release.changes_the_package("pyproject.toml", self.PREFIXES)
+
+    def test_the_sidecar_projects_are_not(self):
+        assert not release.changes_the_package("visualizer-web/data/points.ts", self.PREFIXES)
+        assert not release.changes_the_package("validator/comparison/score.py", self.PREFIXES)
+        assert not release.changes_the_package("plans/deepseek-v4-b200-bringup.md", self.PREFIXES)
+
+    def test_prose_tests_and_measurements_ship_without_being_worth_a_version(self):
+        # Every one of these is inside the sdist -- `is_packaged` says yes and the answer is no.
+        assert release.is_packaged("docs/USAGE.md", self.PREFIXES)
+        assert not release.changes_the_package("docs/USAGE.md", self.PREFIXES)
+        assert not release.changes_the_package("README.md", self.PREFIXES)
+        assert not release.changes_the_package("tests/test_points.py", self.PREFIXES)
+        assert not release.changes_the_package("benchmarks/results/gpt2.json", self.PREFIXES)
+
+    def test_a_markdown_file_beside_the_engine_is_still_only_prose(self):
+        assert not release.changes_the_package("interp_engine/README.md", self.PREFIXES)
+        assert release.changes_the_package("interp_engine/vllm_capture/mhc.py", self.PREFIXES)
+
+    def test_the_first_release_needs_no_comparison(self):
+        cut, why = release.release_plan("1.1.0", None, "auto", self.PREFIXES)
+        assert cut is True
+        assert "no v* tag" in why
+
+    def test_a_hand_declared_version_releases_whatever_changed(self):
+        # The escape hatch for a docs-only release, and for repairing a version that reached PyPI
+        # untagged. It is read before anything is diffed, so it cannot be overruled.
+        cut, why = release.release_plan("2.0.0", "1.4.3", "auto", self.PREFIXES)
+        assert cut is True
+        assert "by hand" in why
+
+    def test_a_dispatched_bump_releases_whatever_changed(self):
+        cut, why = release.release_plan("1.4.3", "1.4.3", "minor", self.PREFIXES)
+        assert cut is True
+        assert "by hand" in why
+
+
 class TestWhetherToUpload:
     PREFIXES = ["interp_engine", "tests", "docs", "README.md", "pyproject.toml"]