From 86e927d60b5d7e9a6ee6e5313e676f1c46f41ce1 Mon Sep 17 00:00:00 2001
From: CometAPI <support@cometapi.com>
Date: Thu, 30 Jul 2026 21:39:20 +0800
Subject: [PATCH] fix: prevent stale mutable release claims

---
 .github/workflows/ci.yml                 |   6 +-
 AGENTS.md                                |  19 +-
 CONTRIBUTING.md                          |   2 +-
 README.md                                |   2 +-
 RELEASING.md                             |   2 +-
 ROADMAP.md                               |  16 +-
 scripts/_checks.py                       | 501 ++++++++++++++++++++++-
 scripts/check_artifacts.py               |  33 +-
 scripts/check_repository_independence.py |  23 +-
 scripts/check_version.py                 |  31 +-
 scripts/check_workflows.py               |   7 +-
 tests/test_release_documents.py          | 359 +++++++++++++++-
 tests/test_release_workflow.py           |  31 +-
 13 files changed, 970 insertions(+), 62 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bbd9285..454432c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -44,10 +44,8 @@ jobs:
         run: uv run pyright
       - name: Run offline unit and contract tests
         run: uv run pytest -m "not live"
-      - name: Check release version agreement
-        run: uv run python scripts/check_version.py --require-changelog
-      - name: Check canonical public content and identity
-        run: uv run python scripts/check_version.py --require-public-preview-docs
+      - name: Check version agreement and durable public content
+        run: uv run python scripts/check_version.py --require-changelog --require-public-preview-docs
       - name: Scan for credentials and scope mistakes
         run: uv run python scripts/check_secrets.py
       - name: Validate workflow syntax with checksum-pinned actionlint
diff --git a/AGENTS.md b/AGENTS.md
index a18c021..a3bdee8 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -50,10 +50,13 @@ proves only its own evidence layer. Never invent or mock missing evidence.
 
 ## Current milestone: Stable 0.1
 
-Stable 0.1 is complete: `cometapi==0.1.1` is the latest publicly available
-maintenance release, and its release and registry trust chain has been
-verified. Do not begin 0.2 provider adapters without a separate maintainer
-request that authorizes that milestone.
+Verified stable `0.1.x` maintenance releases are available from PyPI. The
+public PyPI registry is authoritative for the latest published version.
+`pyproject.toml` and `.release-please-manifest.json` are authoritative for the
+current repository candidate and must agree; a candidate must not be described
+as published. `ROADMAP.md`, `RELEASING.md`, and `CHANGELOG.md` retain exact
+versions only as dated immutable historical evidence. Do not begin 0.2 provider
+adapters without a separate maintainer request that authorizes that milestone.
 
 Private Remote Validation, the sanitized first history, private initialization,
 pre-visibility closeout, public visibility configuration, Public Preview,
@@ -174,6 +177,12 @@ Post-stable invariants:
     release-link text in both source and built artifact metadata, and require
     each built long description to exactly match the source README. Post-release
     evidence changes must not rewrite README release state.
+11. Never encode a mutable "latest/current published patch version" in
+    persistent guidance or current-state documentation. Query public PyPI when
+    current registry state is required. Keep candidate version truth in
+    `pyproject.toml` and `.release-please-manifest.json`, and keep exact released
+    versions only in immutable historical evidence. The document/version
+    checker must fail before merge or release when this boundary is violated.
 
 ## Repository independence
 
@@ -270,7 +279,7 @@ uv run ruff check src tests scripts
 uv run ruff format --check src tests scripts
 uv run pyright
 uv run pytest -m "not live"
-uv run python scripts/check_version.py --require-changelog
+uv run python scripts/check_version.py --require-changelog --require-public-preview-docs
 uv run python scripts/check_secrets.py
 uv run python scripts/check_workflows.py
 rm -rf dist
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2ca3b04..55fb740 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -26,7 +26,7 @@ uv run ruff check src tests scripts
 uv run ruff format --check src tests scripts
 uv run pyright
 uv run pytest -m "not live"
-uv run python scripts/check_version.py --require-changelog
+uv run python scripts/check_version.py --require-changelog --require-public-preview-docs
 uv run python scripts/check_secrets.py
 uv run python scripts/check_workflows.py
 rm -rf dist
diff --git a/README.md b/README.md
index 836cb00..e640d55 100644
--- a/README.md
+++ b/README.md
@@ -180,7 +180,7 @@ uv run ruff check src tests scripts
 uv run ruff format --check src tests scripts
 uv run pyright
 uv run pytest -m "not live"
-uv run python scripts/check_version.py --require-changelog
+uv run python scripts/check_version.py --require-changelog --require-public-preview-docs
 uv run python scripts/check_secrets.py
 uv run python scripts/check_workflows.py
 rm -rf dist
diff --git a/RELEASING.md b/RELEASING.md
index 9321597..0660356 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -83,7 +83,7 @@ uv run ruff check src tests scripts
 uv run ruff format --check src tests scripts
 uv run pyright
 uv run pytest -m "not live"
-uv run python scripts/check_version.py --require-changelog
+uv run python scripts/check_version.py --require-changelog --require-public-preview-docs
 uv run python scripts/check_secrets.py
 uv run python scripts/check_workflows.py
 rm -rf dist
diff --git a/ROADMAP.md b/ROADMAP.md
index b0abb78..3df43e5 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,6 +1,6 @@
 # CometAPI Python SDK Roadmap
 
-Status: `0.1.2` stable maintenance released
+Status: Stable `0.1.x` maintenance active
 Last updated: 2026-07-30
 Repository contract: this roadmap is self-contained.
 Current gate: maintain the verified stable 0.1 surface. Begin 0.2 only after a
@@ -12,13 +12,13 @@ The SDK provides the shortest reliable path from an OpenAI Python integration
 to CometAPI while preserving official request, response, error, retry, timeout,
 sync, async, and streaming behavior.
 
-Private Remote Validation, Public Preview, the functional `0.1.0a1` Registry
-Alpha, stable `0.1.0`, and maintenance releases `0.1.1` and `0.1.2` are complete
-for the sanitized public repository. Protected repository configuration,
-public default-branch CI, exact-release live smoke, PyPI OIDC publication,
-provenance, digest comparison, and public-registry smoke provide separate
-evidence layers. Only 0.1.x maintenance is active; `0.1.2` does not activate
-0.2 scope.
+Private Remote Validation, Public Preview, the functional Registry Alpha, the
+first stable release, and verified `0.1.x` maintenance releases are complete
+for the sanitized public repository and recorded below as immutable evidence.
+Protected repository configuration, public default-branch CI, exact-release
+live smoke, PyPI OIDC publication, provenance, digest comparison, and
+public-registry smoke provide separate evidence layers. Only 0.1.x maintenance
+is active; no maintenance release activates 0.2 scope.
 Support and release claims remain limited to the evidence defined in this
 roadmap and `COMPATIBILITY.md`.
 
diff --git a/scripts/_checks.py b/scripts/_checks.py
index 777eb6f..e5e1f30 100644
--- a/scripts/_checks.py
+++ b/scripts/_checks.py
@@ -3,14 +3,18 @@
 from __future__ import annotations
 
 import hashlib
+import html
 import json
 import re
 import sys
+import unicodedata
 from collections.abc import Iterable
+from datetime import date
 from email.message import Message
 from email.parser import Parser
+from itertools import pairwise
 from pathlib import Path
-from typing import cast
+from typing import NamedTuple, cast
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -33,6 +37,180 @@
     "Security": CANONICAL_SECURITY,
 }
 PUBLIC_README_INSTALL_COMMAND = "python -m pip install cometapi"
+PERSISTENT_DOCUMENTS = (
+    "README.md",
+    "ROADMAP.md",
+    "CHANGELOG.md",
+    "AGENTS.md",
+    "RELEASING.md",
+    "COMPATIBILITY.md",
+    "ARCHITECTURE.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "SUPPORT.md",
+    "CODE_OF_CONDUCT.md",
+    "CLAUDE.md",
+    ".github/PULL_REQUEST_TEMPLATE.md",
+    ".github/ISSUE_TEMPLATE/bug_report.yml",
+    ".github/ISSUE_TEMPLATE/config.yml",
+    ".github/ISSUE_TEMPLATE/feature_request.yml",
+)
+SDIST_PUBLIC_DOCUMENTS = tuple(
+    name for name in PERSISTENT_DOCUMENTS if not name.startswith(".github/") and name != "CLAUDE.md"
+)
+MUTABLE_PUBLISHED_VERSION_FIX = (
+    "replace the exact patch with version-neutral 0.1.x guidance, query PyPI for current "
+    "registry state, and keep exact released versions only in immutable historical evidence"
+)
+MUTABLE_PUBLISHED_VERSION_CATEGORY = "mutable latest/current published patch version"
+_BARE_PATCH_VERSION = r"v?\d+\.\d+\.\d+(?:[-_.]?(?:a|alpha)[-_.]?\d+)?(?:\+[0-9A-Za-z.-]+)?"
+_EXACT_PATCH_VERSION = rf"(?<![\w.])(?:cometapi\s*==\s*)?{_BARE_PATCH_VERSION}(?!\w|\.\d)"
+_HTTP_URL = re.compile(r"https?://[^\s<>)\]]+", flags=re.IGNORECASE)
+_HTML = re.compile(r"<!--.*?-->|<[^>]*>", flags=re.DOTALL)
+_MARKDOWN_LINK = re.compile(r"\[([^\]]+)\]\((?:[^()]|\([^()]*\))*\)")
+_VERSIONED_RELEASE_URL = re.compile(
+    rf"https?://(?:"
+    rf"pypi\.org/project/cometapi/(?P<pypi>{_BARE_PATCH_VERSION})"
+    rf"|github\.com/cometapi-dev/cometapi-python/releases/tag/(?P<github>{_BARE_PATCH_VERSION})"
+    rf")(?=$|[/#?\s<>\"')\]])",
+    flags=re.IGNORECASE,
+)
+_CLAIM_TOKEN = re.compile(
+    rf"(?P<version>{_EXACT_PATCH_VERSION})"
+    r"|(?P<word>[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*)"
+    r"|(?P<boundary>[.!?;](?=\s|$))"
+    r"|(?P<separator>[,:|\u2013\u2014])",
+    flags=re.IGNORECASE,
+)
+_CURRENT_WORDS = {"current", "currently", "latest", "newest", "now"}
+_RELEASE_IDENTITY_WORDS = {"build", "distribution", "patch", "release", "version"}
+_PUBLICATION_STATE_WORDS = {
+    "available",
+    "hosts",
+    "lists",
+    "offers",
+    "published",
+    "publishes",
+    "released",
+    "serves",
+}
+_HISTORICAL_ACTION_WORDS = {
+    "accepted",
+    "completed",
+    "created",
+    "executed",
+    "failed",
+    "passed",
+    "published",
+    "reached",
+    "reserved",
+    "verified",
+}
+_PRESENT_WORDS = {"are", "is", "now", "currently", "remains"}
+_PAST_WORDS = {"had", "was", "were"}
+_ATTRIBUTION_SKIP_WORDS = {
+    "a",
+    "an",
+    "accepted",
+    "active",
+    "are",
+    "as",
+    "at",
+    "available",
+    "build",
+    "candidate",
+    "client",
+    "cometapi",
+    "completed",
+    "current",
+    "currently",
+    "distribution",
+    "exact",
+    "for",
+    "from",
+    "has",
+    "hosts",
+    "immutable",
+    "install",
+    "installed",
+    "is",
+    "its",
+    "latest",
+    "library",
+    "lists",
+    "maintenance",
+    "most",
+    "newest",
+    "now",
+    "of",
+    "offers",
+    "on",
+    "our",
+    "package",
+    "patch",
+    "project",
+    "public",
+    "publicly",
+    "published",
+    "publishes",
+    "recent",
+    "registry",
+    "release",
+    "released",
+    "repository",
+    "sdk",
+    "serves",
+    "stable",
+    "status",
+    "supported",
+    "that",
+    "the",
+    "these",
+    "this",
+    "those",
+    "verified",
+    "version",
+    "was",
+    "were",
+}
+_IMMUTABLE_CONTEXT_WORDS = {
+    "commit",
+    "completed",
+    "digest",
+    "evidence",
+    "executed",
+    "immutable",
+    "recovery",
+    "run",
+    "tag",
+    "workflow",
+}
+_CANONICAL_ATTRIBUTIONS = {
+    "client",
+    "cometapi",
+    "cometapi-python",
+    "library",
+    "package",
+    "project",
+    "repository",
+    "sdk",
+    "this",
+}
+_KNOWN_THIRD_PARTY_ATTRIBUTIONS = {
+    "httpx",
+    "openai",
+    "pyright",
+    "pytest",
+    "ruff",
+    "twine",
+    "uv",
+}
+_MUTABLE_LABEL_WORDS = {
+    "current",
+    "latest",
+    "newest",
+    "pypi",
+}
 PUBLIC_README_FORBIDDEN_PATTERNS = (
     (r"(?i)\bpending[\s-]+owner(?:ship|s)?\b", "pending owner identity"),
     (r"(?i)\bapproved\s+for\s+pypi\s+publication\b", "publication approval state"),
@@ -58,6 +236,244 @@ class CheckError(RuntimeError):
     """Raised when release-candidate evidence does not satisfy a local gate."""
 
 
+class _ClaimToken(NamedTuple):
+    kind: str
+    value: str
+    start: int
+    end: int
+
+
+def _visible_release_url_versions(value: str) -> str:
+    """Expose release URL versions while preserving offsets and line numbers."""
+    replacement = ["\n" if character == "\n" else " " for character in value]
+    for match in _VERSIONED_RELEASE_URL.finditer(value):
+        group = "pypi" if match.group("pypi") is not None else "github"
+        start, end = match.span(group)
+        marker = "immutableurl"
+        marker_start = max(match.start(), start - len(marker) - 1)
+        replacement[marker_start : marker_start + len(marker)] = marker
+        replacement[start:end] = value[start:end]
+    return "".join(replacement)
+
+
+def _replace_html(match: re.Match[str]) -> str:
+    """Discard markup without shifting line numbers used in diagnostics."""
+    value = match.group(0)
+    if value.startswith("<!--"):
+        return "".join("\n" if character == "\n" else " " for character in value)
+    return _visible_release_url_versions(value)
+
+
+def _replace_markdown_link(match: re.Match[str]) -> str:
+    """Keep link labels and exact release URL versions visible to the claim detector."""
+    value = match.group(0)
+    replacement = list(_visible_release_url_versions(value))
+    label = match.group(1)
+    label_start = value.find(label)
+    label_end = label_start + len(label)
+    replacement[label_start:label_end] = label
+    return "".join(replacement)
+
+
+def _claim_analysis_text(text: str) -> str:
+    normalized = unicodedata.normalize("NFKC", html.unescape(text))
+    normalized = _HTML.sub(_replace_html, normalized)
+    normalized = _MARKDOWN_LINK.sub(_replace_markdown_link, normalized)
+    normalized = _VERSIONED_RELEASE_URL.sub(
+        lambda match: _visible_release_url_versions(match.group(0)), normalized
+    )
+    normalized = re.sub(r"\\([`*_{}\[\]()#+.!|~>-])", r"\1", normalized)
+    normalized = re.sub(r"[`*_~#\[\]{}]", " ", normalized)
+    return normalized
+
+
+def _claim_tokens(text: str) -> list[_ClaimToken]:
+    url_spans = [(match.start(), match.end()) for match in _HTTP_URL.finditer(text)]
+    tokens: list[_ClaimToken] = []
+    for match in _CLAIM_TOKEN.finditer(text):
+        kind = match.lastgroup
+        if kind is None:
+            continue
+        if kind == "version" and any(
+            start <= match.start() and match.end() <= end for start, end in url_spans
+        ):
+            continue
+        tokens.append(_ClaimToken(kind, match.group(0).casefold(), match.start(), match.end()))
+    return tokens
+
+
+def _claim_window(tokens: list[_ClaimToken], version_index: int) -> list[_ClaimToken]:
+    start = version_index
+    words = 0
+    while start > 0 and words < 32:
+        previous = tokens[start - 1]
+        if previous.kind == "boundary" or (
+            previous.kind == "separator" and previous.value == "|" and words >= 1
+        ):
+            break
+        start -= 1
+        words += previous.kind in {"word", "version"}
+
+    end = version_index + 1
+    words = 0
+    while end < len(tokens) and words < 32:
+        following = tokens[end]
+        if following.kind == "boundary" or (
+            following.kind == "separator" and following.value == "|" and words >= 1
+        ):
+            break
+        end += 1
+        words += following.kind in {"word", "version"}
+    return tokens[start:end]
+
+
+def _word_values(tokens: Iterable[_ClaimToken]) -> list[str]:
+    return [token.value for token in tokens if token.kind == "word"]
+
+
+def _has_current_marker(words: list[str]) -> bool:
+    return bool(_CURRENT_WORDS.intersection(words)) or any(
+        first == "most" and second == "recent" for first, second in pairwise(words)
+    )
+
+
+def _valid_historical_snapshot(words: list[str]) -> bool:
+    if not _has_current_marker(words):
+        return False
+    dated_indexes: list[int] = []
+    for index, value in enumerate(words):
+        try:
+            date.fromisoformat(value)
+        except ValueError:
+            continue
+        dated_indexes.append(index)
+    if not dated_indexes:
+        return False
+
+    word_set = set(words)
+    if {"historical", "snapshot"}.issubset(word_set):
+        return True
+    if not _PAST_WORDS.intersection(word_set) or _PRESENT_WORDS.intersection(word_set):
+        return False
+    if "evidence" in word_set and bool({"publication", "release"}.intersection(word_set)):
+        return True
+    for index in dated_indexes:
+        prefix = words[index - 1] if index else ""
+        if prefix in {"at", "on"} or words[max(0, index - 2) : index] == ["as", "of"]:
+            return True
+    return False
+
+
+def _explicit_third_party_attribution(
+    window: list[_ClaimToken], version_index: int, version_value: str
+) -> bool:
+    if version_value.startswith("cometapi"):
+        return False
+    words_before = _word_values(window[:version_index])
+    words_after = _word_values(window[version_index + 1 :])
+
+    candidates: list[str] = []
+    if words_before and words_before[-1] in _KNOWN_THIRD_PARTY_ATTRIBUTIONS:
+        candidates.append(words_before[-1])
+    for index, word in enumerate(words_before):
+        if word not in _KNOWN_THIRD_PARTY_ATTRIBUTIONS:
+            continue
+        trailing = words_before[index + 1 :]
+        if any(
+            value in _RELEASE_IDENTITY_WORDS | _CURRENT_WORDS | {"stable"} for value in trailing
+        ):
+            candidates.append(word)
+    for index, word in enumerate(words_before[:-1]):
+        if word in _RELEASE_IDENTITY_WORDS and words_before[index + 1] in {"for", "of"}:
+            if index + 2 < len(words_before):
+                candidates.append(words_before[index + 2])
+    for index, word in enumerate(words_after[:-2]):
+        if word in _RELEASE_IDENTITY_WORDS and words_after[index + 1] in {"for", "of"}:
+            candidates.append(words_after[index + 2])
+
+    attributed = next(
+        (
+            candidate
+            for candidate in reversed(candidates)
+            if candidate not in _ATTRIBUTION_SKIP_WORDS
+        ),
+        None,
+    )
+    return attributed is not None and attributed not in _CANONICAL_ATTRIBUTIONS
+
+
+def _is_mutable_published_version_claim(window: list[_ClaimToken], version_index: int) -> bool:
+    words = _word_values(window)
+    version_value = window[version_index].value
+    if _explicit_third_party_attribution(window, version_index, version_value):
+        return False
+    if _valid_historical_snapshot(words):
+        return False
+
+    word_set = set(words)
+    has_identity = bool(_RELEASE_IDENTITY_WORDS.intersection(word_set))
+    has_registry = bool({"pypi", "registry"}.intersection(word_set))
+    has_publication = bool(_PUBLICATION_STATE_WORDS.intersection(word_set))
+    has_current = _has_current_marker(words)
+    immutable_release_url = "immutableurl" in word_set
+    if (
+        immutable_release_url
+        and not has_current
+        and not {"are", "now", "currently", "remains"}.intersection(word_set)
+        and not {"available", "hosts", "lists", "offers", "publishes", "serves"}.intersection(
+            word_set
+        )
+    ):
+        return False
+    immutable_history = bool(_IMMUTABLE_CONTEXT_WORDS.intersection(word_set)) and bool(
+        _HISTORICAL_ACTION_WORDS.intersection(word_set)
+    )
+    if "status" in word_set and "released" in word_set:
+        return True
+    if has_current and has_identity:
+        return True
+    if has_current and ("stable" in word_set or has_registry):
+        return True
+    if has_current and "cometapi" in word_set:
+        return True
+    if has_current and has_publication and (has_registry or "cometapi" in word_set):
+        return True
+
+    # A dated, past-tense publication event is immutable evidence, not current state.
+    publication_index = next(
+        (index for index, word in enumerate(words) if word in _PUBLICATION_STATE_WORDS),
+        -1,
+    )
+    past_index = next((index for index, word in enumerate(words) if word in _PAST_WORDS), -1)
+    conjunction_after_past = any(
+        word in {"and", "but", "so", "therefore"}
+        for word in words[past_index + 1 : publication_index]
+    )
+    if (
+        past_index >= 0
+        and publication_index >= 0
+        and past_index < publication_index
+        and not _PRESENT_WORDS.intersection(words[past_index + 1 :])
+        and not conjunction_after_past
+    ):
+        return False
+
+    if immutable_history and not has_current:
+        return False
+    # Present-state publication forms do not need an explicit latest/current marker.
+    if has_identity and has_publication:
+        return True
+    if has_registry and has_publication:
+        return True
+    if has_registry and "cometapi" in word_set:
+        return True
+    if "available" in word_set and "publicly" in word_set:
+        return True
+    if re.search(r"\b(?:pypi|registry)\s+(?:release|version|distribution)\b", " ".join(words)):
+        return True
+    return False
+
+
 def read_project_metadata(root: Path = PROJECT_ROOT) -> dict[str, object]:
     """Return the parsed PEP 621 project table."""
     path = root / "pyproject.toml"
@@ -138,9 +554,90 @@ def metadata_description(message: Message, source: str) -> str:
 
 def public_readme_release_violations(text: str) -> list[str]:
     """Return transient or version-specific release statements in public README text."""
-    return [
+    violations = [
         label for pattern, label in PUBLIC_README_FORBIDDEN_PATTERNS if re.search(pattern, text)
     ]
+    violations.extend(label for _, label in mutable_published_version_claims(text))
+    return violations
+
+
+def mutable_published_version_claims(text: str) -> list[tuple[int, str]]:
+    """Return line-numbered mutable exact-patch publication claims."""
+    searchable = _claim_analysis_text(text)
+    tokens = _claim_tokens(searchable)
+    findings: set[tuple[int, str]] = set()
+    for index, token in enumerate(tokens):
+        if token.kind != "version":
+            continue
+        window = _claim_window(tokens, index)
+        window_index = window.index(token)
+        # Markdown tables often put the mutable state in the cell after the
+        # version. Include that adjacent cell even though normal claim windows
+        # stop at a pipe boundary.
+        table_suffix: list[str] = []
+        if index + 1 < len(tokens) and tokens[index + 1].kind == "separator":
+            if tokens[index + 1].value == "|":
+                suffix_end = index + 2
+                while suffix_end < len(tokens):
+                    following = tokens[suffix_end]
+                    if following.kind == "boundary" or (
+                        following.kind == "separator" and following.value == "|"
+                    ):
+                        break
+                    suffix_end += 1
+                table_suffix = _word_values(tokens[index + 2 : suffix_end])
+        colon_label: list[str] = []
+        if index > 0 and (
+            (tokens[index - 1].kind == "separator" and tokens[index - 1].value == ":")
+            or (tokens[index - 1].kind == "separator" and tokens[index - 1].value == "|")
+        ):
+            label_start = index - 2
+            while label_start >= 0 and tokens[label_start].kind != "boundary":
+                if tokens[label_start].kind == "separator" and tokens[label_start].value == "|":
+                    break
+                label_start -= 1
+            colon_label = _word_values(tokens[label_start + 1 : index - 1])[-8:]
+        prefix = searchable[max(0, token.start - 160) : token.start]
+        parenthetical = re.search(r"([^.!?;]{0,100})\(([^()]*)\)\s*:\s*$", prefix)
+        if parenthetical is not None:
+            colon_label.extend(
+                re.findall(
+                    r"[A-Za-z0-9]+(?:[-'][A-Za-z0-9]+)*",
+                    " ".join(parenthetical.groups()).casefold(),
+                )[-12:]
+            )
+        label_words = set(colon_label)
+        mutable_label = (
+            bool(label_words.intersection(_MUTABLE_LABEL_WORDS))
+            or (
+                bool(label_words.intersection({"public", "stable"}))
+                and bool(label_words.intersection(_RELEASE_IDENTITY_WORDS))
+            )
+            or bool(label_words.intersection({"released", "published"}))
+        )
+        mutable_table_suffix = bool(
+            set(table_suffix).intersection(
+                _CURRENT_WORDS | _PUBLICATION_STATE_WORDS | {"stable", "status"}
+            )
+        )
+        attributed_label = (
+            bool(label_words.intersection(_KNOWN_THIRD_PARTY_ATTRIBUTIONS))
+            and "cometapi" not in label_words
+        )
+        window_words = _word_values(window)
+        recovery_mapping = (
+            "remains" in window_words
+            and bool({"artifact", "identity", "recovery"}.intersection(set(window_words)))
+            and not _has_current_marker(window_words)
+            and "but" not in window_words
+        )
+        if (
+            ((mutable_label or mutable_table_suffix) and not attributed_label)
+            or _is_mutable_published_version_claim(window, window_index)
+        ) and not recovery_mapping:
+            line = searchable.count("\n", 0, token.start) + 1
+            findings.add((line, MUTABLE_PUBLISHED_VERSION_CATEGORY))
+    return sorted(findings)
 
 
 def public_readme_has_install_command(text: str) -> bool:
diff --git a/scripts/check_artifacts.py b/scripts/check_artifacts.py
index 8ab4e5f..d7c35b1 100644
--- a/scripts/check_artifacts.py
+++ b/scripts/check_artifacts.py
@@ -13,10 +13,13 @@
     from ._checks import (
         CANONICAL_AUTHOR,
         CANONICAL_PROJECT_URLS,
+        MUTABLE_PUBLISHED_VERSION_FIX,
         PROJECT_ROOT,
         PUBLIC_README_INSTALL_COMMAND,
+        SDIST_PUBLIC_DOCUMENTS,
         CheckError,
         metadata_description,
+        mutable_published_version_claims,
         normalize_version,
         parse_metadata,
         public_readme_has_install_command,
@@ -28,10 +31,13 @@
     from _checks import (
         CANONICAL_AUTHOR,
         CANONICAL_PROJECT_URLS,
+        MUTABLE_PUBLISHED_VERSION_FIX,
         PROJECT_ROOT,
         PUBLIC_README_INSTALL_COMMAND,
+        SDIST_PUBLIC_DOCUMENTS,
         CheckError,
         metadata_description,
+        mutable_published_version_claims,
         normalize_version,
         parse_metadata,
         public_readme_has_install_command,
@@ -156,7 +162,7 @@ def check_metadata(
         )
 
 
-def _check_wheel(path: Path, expected_version: str, expected_description: str) -> None:
+def check_wheel(path: Path, expected_version: str, expected_description: str) -> None:
     expected_fragment = f"cometapi-{expected_version}-"
     if expected_fragment not in path.name:
         raise CheckError(f"{path.name}: filename does not contain {expected_fragment!r}")
@@ -194,7 +200,7 @@ def _check_wheel(path: Path, expected_version: str, expected_description: str) -
                 raise CheckError(f"{path.name}:{source_name}: legacy public client name remains")
 
 
-def _check_sdist(path: Path, expected_version: str, expected_description: str) -> None:
+def check_sdist(path: Path, expected_version: str, expected_description: str) -> None:
     expected_root = f"cometapi-{expected_version}"
     if path.name != f"{expected_root}.tar.gz":
         raise CheckError(f"{path.name}: expected sdist filename {expected_root}.tar.gz")
@@ -205,11 +211,12 @@ def _check_sdist(path: Path, expected_version: str, expected_description: str) -
             raise CheckError(f"{path.name}: links and device members are forbidden")
         if any(item.parts[0] != expected_root for item in paths):
             raise CheckError(f"{path.name}: every member must be below {expected_root}/")
-        relative_files = {
-            PurePosixPath(*item.parts[1:]).as_posix()
+        relative_members = {
+            PurePosixPath(*item.parts[1:]).as_posix(): member
             for member, item in zip(members, paths, strict=True)
             if member.isfile()
         }
+        relative_files = set(relative_members)
         missing = REQUIRED_SDIST_FILES - relative_files
         if missing:
             raise CheckError(f"{path.name}: missing sdist files: {sorted(missing)}")
@@ -217,6 +224,20 @@ def _check_sdist(path: Path, expected_version: str, expected_description: str) -
         unexpected = sorted(relative_files - expected_files)
         if unexpected:
             raise CheckError(f"{path.name}: unexpected sdist files: {unexpected}")
+        for name in SDIST_PUBLIC_DOCUMENTS:
+            stream = archive.extractfile(relative_members[name])
+            if stream is None:
+                raise CheckError(f"{path.name}:{name}: cannot read public document")
+            try:
+                text = stream.read().decode("utf-8")
+            except UnicodeDecodeError as exc:
+                raise CheckError(f"{path.name}:{name}: document is not UTF-8: {exc}") from exc
+            claims = mutable_published_version_claims(text)
+            if claims:
+                line, label = claims[0]
+                raise CheckError(
+                    f"{path.name}:{name}:{line}: contains {label}; {MUTABLE_PUBLISHED_VERSION_FIX}"
+                )
         metadata_members = [
             member for member in members if PurePosixPath(member.name).name == "PKG-INFO"
         ]
@@ -261,9 +282,9 @@ def main() -> int:
     paths = _artifacts(args.artifacts)
     for path in paths:
         if path.suffix == ".whl":
-            _check_wheel(path, expected_version, expected_description)
+            check_wheel(path, expected_version, expected_description)
         else:
-            _check_sdist(path, expected_version, expected_description)
+            check_sdist(path, expected_version, expected_description)
         print(f"{sha256_file(path)}  {path}")
     print(f"artifact checks passed for cometapi {expected_version}")
     return 0
diff --git a/scripts/check_repository_independence.py b/scripts/check_repository_independence.py
index fc2189a..eb294b2 100644
--- a/scripts/check_repository_independence.py
+++ b/scripts/check_repository_independence.py
@@ -10,7 +10,10 @@
 import tempfile
 from pathlib import Path
 
-from _checks import PROJECT_ROOT, CheckError
+try:
+    from ._checks import PROJECT_ROOT, CheckError
+except ImportError:  # Direct execution from the repository root.
+    from _checks import PROJECT_ROOT, CheckError
 
 IGNORED_NAMES = {
     ".cache",
@@ -74,8 +77,9 @@ def _run(root: Path, command: list[str]) -> None:
     subprocess.run(command, cwd=root, env=_environment(), check=True, timeout=1200)
 
 
-def _offline_checks(root: Path) -> None:
-    commands = [
+def offline_check_commands() -> list[list[str]]:
+    """Return the ordered standalone command templates."""
+    return [
         ["uv", "lock", "--check"],
         ["uv", "sync", "--locked"],
         ["uv", "run", "ruff", "check", "src", "tests", "scripts"],
@@ -83,12 +87,12 @@ def _offline_checks(root: Path) -> None:
         ["uv", "run", "pyright"],
         ["uv", "run", "pytest", "-m", "not live"],
         ["uv", "run", "python", "scripts/check_secrets.py"],
-        ["uv", "run", "python", "scripts/check_version.py", "--require-changelog"],
         [
             "uv",
             "run",
             "python",
             "scripts/check_version.py",
+            "--require-changelog",
             "--require-public-preview-docs",
         ],
         ["uv", "run", "python", "scripts/check_workflows.py"],
@@ -96,14 +100,15 @@ def _offline_checks(root: Path) -> None:
         ["uv", "build"],
         ["uv", "run", "twine", "check", "dist/*"],
         ["uv", "run", "python", "scripts/check_artifacts.py"],
+        ["uv", "run", "python", "scripts/check_clean_install.py", "dist/*"],
     ]
-    for command in commands:
+
+
+def _offline_checks(root: Path) -> None:
+    for command in offline_check_commands():
         if command[-1] == "dist/*":
-            artifacts = _distribution_paths(root)
-            command = command[:-1] + artifacts
+            command = command[:-1] + _distribution_paths(root)
         _run(root, command)
-    artifacts = _distribution_paths(root)
-    _run(root, ["uv", "run", "python", "scripts/check_clean_install.py", *artifacts])
 
 
 def _distribution_paths(root: Path) -> list[str]:
diff --git a/scripts/check_version.py b/scripts/check_version.py
index cd82438..907b67d 100644
--- a/scripts/check_version.py
+++ b/scripts/check_version.py
@@ -18,8 +18,11 @@
         CANONICAL_SECURITY,
         CANONICAL_SUPPORT,
         DIST_NAME,
+        MUTABLE_PUBLISHED_VERSION_FIX,
+        PERSISTENT_DOCUMENTS,
         PUBLIC_README_INSTALL_COMMAND,
         CheckError,
+        mutable_published_version_claims,
         normalize_version,
         public_readme_has_install_command,
         public_readme_release_violations,
@@ -37,8 +40,11 @@
         CANONICAL_SECURITY,
         CANONICAL_SUPPORT,
         DIST_NAME,
+        MUTABLE_PUBLISHED_VERSION_FIX,
+        PERSISTENT_DOCUMENTS,
         PUBLIC_README_INSTALL_COMMAND,
         CheckError,
+        mutable_published_version_claims,
         normalize_version,
         public_readme_has_install_command,
         public_readme_release_violations,
@@ -90,20 +96,6 @@ def _require_canonical_tag(tag: str, project_version: str) -> str:
     return normalized
 
 
-PUBLIC_DOCUMENTS = (
-    "README.md",
-    "ROADMAP.md",
-    "CHANGELOG.md",
-    "AGENTS.md",
-    "RELEASING.md",
-    "COMPATIBILITY.md",
-    "ARCHITECTURE.md",
-    "CONTRIBUTING.md",
-    "SECURITY.md",
-    "SUPPORT.md",
-    "CODE_OF_CONDUCT.md",
-)
-
 FORBIDDEN_PUBLIC_PATTERNS = {
     r"(?i)registry alpha ready for owner action": "handoff state",
     r"(?i)pending owner action": "owner-action placeholder",
@@ -121,7 +113,7 @@ def _require_canonical_tag(tag: str, project_version: str) -> str:
 
 def _read_public_documents(violations: list[str]) -> dict[str, str]:
     documents: dict[str, str] = {}
-    for name in PUBLIC_DOCUMENTS:
+    for name in PERSISTENT_DOCUMENTS:
         try:
             documents[name] = Path(name).read_text(encoding="utf-8")
         except (OSError, UnicodeError) as exc:
@@ -170,6 +162,14 @@ def _check_standalone_links(documents: dict[str, str], violations: list[str]) ->
                 violations.append(f"{name}: link target does not exist: {raw_target!r}")
 
 
+def _check_mutable_release_claims(documents: dict[str, str], violations: list[str]) -> None:
+    for name, text in documents.items():
+        for line, label in mutable_published_version_claims(text):
+            violation = f"{name}:{line}: contains {label}; {MUTABLE_PUBLISHED_VERSION_FIX}"
+            if violation not in violations:
+                violations.append(violation)
+
+
 def require_public_preview_docs() -> None:
     """Collect every violation, then fail closed until public content is suitable."""
 
@@ -224,6 +224,7 @@ def require_public_preview_docs() -> None:
             if needle in text:
                 violations.append(f"{name}: contains non-standalone {label}")
 
+    _check_mutable_release_claims(documents, violations)
     _check_standalone_links(documents, violations)
     if violations:
         raise CheckError(
diff --git a/scripts/check_workflows.py b/scripts/check_workflows.py
index b84a42b..defc143 100644
--- a/scripts/check_workflows.py
+++ b/scripts/check_workflows.py
@@ -502,8 +502,8 @@ def check_ci_workflow(text: str) -> None:
             "uv run ruff format --check src tests scripts",
             "uv run pyright",
             'uv run pytest -m "not live"',
-            "uv run python scripts/check_version.py --require-changelog",
-            "uv run python scripts/check_version.py --require-public-preview-docs",
+            "uv run python scripts/check_version.py --require-changelog "
+            "--require-public-preview-docs",
             "uv run python scripts/check_secrets.py",
             "uv run python scripts/run_actionlint.py",
             "uv run python scripts/check_workflows.py",
@@ -551,8 +551,7 @@ def check_ci_workflow(text: str) -> None:
             "Check formatting",
             "Type check",
             "Run offline unit and contract tests",
-            "Check release version agreement",
-            "Check canonical public content and identity",
+            "Check version agreement and durable public content",
             "Scan for credentials and scope mistakes",
             "Validate workflow syntax with checksum-pinned actionlint",
             "Verify release-workflow trust semantics",
diff --git a/tests/test_release_documents.py b/tests/test_release_documents.py
index 27ef82b..e97d0f6 100644
--- a/tests/test_release_documents.py
+++ b/tests/test_release_documents.py
@@ -3,22 +3,27 @@
 import shutil
 import subprocess
 import sys
+import tarfile
+import zipfile
 from collections.abc import Callable
 from pathlib import Path
 
 import pytest
 
+from scripts import check_repository_independence
 from scripts._checks import (
     CANONICAL_AUTHOR,
     CANONICAL_COPYRIGHT,
     CANONICAL_PROJECT_URLS,
     CANONICAL_SECURITY,
     CANONICAL_SUPPORT,
+    MUTABLE_PUBLISHED_VERSION_FIX,
     PUBLIC_README_INSTALL_COMMAND,
     CheckError,
+    mutable_published_version_claims,
     read_project_version,
 )
-from scripts.check_artifacts import check_metadata
+from scripts.check_artifacts import check_metadata, check_sdist, check_wheel
 from scripts.check_version import require_public_preview_docs, require_releasable_docs
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
@@ -75,6 +80,11 @@ def _write_release_documents(root: Path) -> None:
         "COMPATIBILITY.md": "# Compatibility\n",
         "ARCHITECTURE.md": "# Architecture\n",
         "CONTRIBUTING.md": "# Contributing\n",
+        "CLAUDE.md": "@AGENTS.md.\n",
+        ".github/PULL_REQUEST_TEMPLATE.md": "# Pull request\n",
+        ".github/ISSUE_TEMPLATE/bug_report.yml": "name: Bug report\n",
+        ".github/ISSUE_TEMPLATE/config.yml": "blank_issues_enabled: false\n",
+        ".github/ISSUE_TEMPLATE/feature_request.yml": "name: Feature request\n",
     }
     for name, content in files.items():
         path = root / name
@@ -147,6 +157,242 @@ def test_public_preview_documents_accept_durable_public_content(
     require_public_preview_docs()
 
 
+@pytest.mark.parametrize(
+    ("document", "claim"),
+    [
+        (
+            "AGENTS.md",
+            "`cometapi==0.1.2` is the latest publicly available maintenance release.",
+        ),
+        ("README.md", "The **current PyPI release** is\n`0.1.2`."),
+        ("COMPATIBILITY.md", "LATEST stable version: **0.1.2**."),
+        ("ARCHITECTURE.md", "`0.1.2` remains the current stable release."),
+        ("ROADMAP.md", "Status: `0.1.2` stable maintenance released"),
+        ("AGENTS.md", "Latest PyPI release: `0.1.2`."),
+        ("README.md", "`0.1.2` is the latest PyPI release."),
+        ("COMPATIBILITY.md", "PyPI currently publishes `0.1.2`."),
+        ("ARCHITECTURE.md", "The currently published version is `0.1.2`."),
+        ("CONTRIBUTING.md", "The version currently available from PyPI is `0.1.2`."),
+        ("AGENTS.md", "Published version: `0.1.2`."),
+        ("README.md", "CometAPI `0.1.2` is available from PyPI."),
+        ("COMPATIBILITY.md", "Latest, stable distribution: `0.1.2`."),
+        ("ARCHITECTURE.md", "PyPI currently has CometAPI `0.1.2`."),
+        ("CONTRIBUTING.md", "The latest <strong>stable</strong> release is `0.1.2`."),
+        (
+            "AGENTS.md",
+            "Historical evidence: immutable tag `v0.1.1`.\n\nCurrent PyPI release: `0.1.2`.",
+        ),
+        ("README.md", "| Current | `0.1.2` |"),
+        (
+            "README.md",
+            "| Version | Status |\n| --- | --- |\n| `0.1.2` | Current |",
+        ),
+        (
+            "README.md",
+            "Current PyPI release: https://pypi.org/project/cometapi/0.1.2/",
+        ),
+        (
+            "README.md",
+            "The **latest stable version** is [`0.1.2`](https://example.invalid).",
+        ),
+        (
+            ".github/ISSUE_TEMPLATE/feature_request.yml",
+            "description: Current PyPI release is 0.1.2.",
+        ),
+        ("COMPATIBILITY.md", "| Status | Released | `0.1.2` |"),
+        ("ARCHITECTURE.md", "The workflow was repaired, so PyPI publishes `0.1.2`."),
+    ],
+    ids=[
+        "agents-old-claim",
+        "readme-markdown-newline",
+        "compatibility-case-markdown",
+        "version-first-current-claim",
+        "roadmap-status",
+        "latest-pypi-release",
+        "version-first-latest-pypi-release",
+        "pypi-currently-publishes",
+        "currently-published-version",
+        "version-currently-available-from-pypi",
+        "published-version",
+        "cometapi-version-available-from-pypi",
+        "punctuated-latest-distribution",
+        "pypi-currently-has-cometapi",
+        "html-latest-release",
+        "prior-immutable-evidence-does-not-exempt-current-claim",
+        "markdown-current-table",
+        "markdown-version-first-current-table",
+        "current-versioned-pypi-url",
+        "markdown-linked-version-label",
+        "issue-template-current-release",
+        "markdown-released-table",
+        "past-clause-does-not-exempt-current-publication",
+    ],
+)
+def test_public_preview_cli_rejects_mutable_published_patch_claims(
+    releasable_documents: Path,
+    document: str,
+    claim: str,
+) -> None:
+    version_script = _copy_version_checker(releasable_documents)
+    with (releasable_documents / document).open("a", encoding="utf-8") as stream:
+        stream.write(f"\n{claim}\n")
+
+    result = subprocess.run(
+        [sys.executable, str(version_script), "--require-public-preview-docs"],
+        cwd=releasable_documents,
+        text=True,
+        check=False,
+        capture_output=True,
+    )
+
+    assert result.returncode != 0
+    assert f"{document}:" in result.stderr
+    assert "mutable " in result.stderr
+    assert "patch" in result.stderr
+    assert MUTABLE_PUBLISHED_VERSION_FIX in result.stderr
+
+
+def test_releasable_cli_rejects_mutable_published_patch_claim(
+    releasable_documents: Path,
+) -> None:
+    version_script = _copy_version_checker(releasable_documents)
+    with (releasable_documents / "AGENTS.md").open("a", encoding="utf-8") as stream:
+        stream.write("\n`cometapi==0.1.2` is the latest publicly available release.\n")
+
+    result = subprocess.run(
+        [sys.executable, str(version_script), "--require-releasable-docs"],
+        cwd=releasable_documents,
+        text=True,
+        check=False,
+        capture_output=True,
+    )
+
+    assert result.returncode != 0
+    assert "AGENTS.md:" in result.stderr
+    assert "mutable latest/current published patch version" in result.stderr
+    assert MUTABLE_PUBLISHED_VERSION_FIX in result.stderr
+
+
+def test_public_preview_documents_allow_immutable_release_evidence(
+    releasable_documents: Path,
+) -> None:
+    evidence = """\
+## Completed 0.1.2 maintenance release evidence
+
+- Release `v0.1.2` at commit `710c56491d9ef5f47cccff3ce837ab7e799455b0`
+  completed workflow run 30515861246 on 2026-07-30.
+- https://pypi.org/project/cometapi/0.1.2/
+- https://github.com/cometapi-dev/cometapi-python/releases/tag/v0.1.2
+- Wheel SHA256: 3f12c26ae1ae7a1de5ac19d8ef27a784b2bf592143c716493f1b0f35ec19daca
+"""
+    for name in ("CHANGELOG.md", "ROADMAP.md", "RELEASING.md"):
+        with (releasable_documents / name).open("a", encoding="utf-8") as stream:
+            stream.write(evidence)
+
+    require_public_preview_docs()
+
+
+@pytest.mark.parametrize(
+    "statement",
+    [
+        "Current stable release of Ruff: 0.12.0.",
+        "Latest stable version of httpx is 0.28.1.",
+        "Current PyPI release of openai: 2.50.0.",
+        "Latest stable OpenAI release: 2.50.0.",
+        "As of 2026-07-30, the current PyPI release was 0.1.2.",
+        "## Release evidence — 2026-07-30\n\nAt publication, 0.1.2 was the current PyPI release.",
+        "Release v0.1.2 is the latest stable version in the historical 2026-07-30 snapshot.",
+        "Release 0.1.2 was published on 2026-07-30.",
+        "The immutable v0.1.2 tag resolves to release commit 710c5649.",
+        "PyPI version remains 0.1.0a1 in recovery identity evidence.",
+        "https://pypi.org/project/cometapi/0.1.2/",
+        "[PyPI 0.1.2](https://pypi.org/project/cometapi/0.1.2/)",
+        "The exact [PyPI release](https://pypi.org/project/cometapi/0.1.2/) is public.",
+    ],
+)
+def test_mutable_claim_detector_allows_attributed_or_historical_evidence(
+    statement: str,
+) -> None:
+    assert mutable_published_version_claims(statement) == []
+
+
+def test_releasable_cli_allows_next_patch_without_guidance_edits(
+    releasable_documents: Path,
+) -> None:
+    version_script = _copy_version_checker(releasable_documents)
+    _replace(releasable_documents, "pyproject.toml", "0.1.0a1", "0.1.3")
+    _replace(
+        releasable_documents,
+        ".release-please-manifest.json",
+        "0.1.0-alpha.1",
+        "0.1.3",
+    )
+    with (releasable_documents / "CHANGELOG.md").open("a", encoding="utf-8") as stream:
+        stream.write("\n## [0.1.3] - 2026-07-30\n\nPatch maintenance.\n")
+
+    command = [
+        sys.executable,
+        str(version_script),
+        "--require-changelog",
+        "--require-releasable-docs",
+    ]
+    initial = subprocess.run(
+        command,
+        cwd=releasable_documents,
+        text=True,
+        check=False,
+        capture_output=True,
+    )
+    assert initial.returncode == 0, initial.stderr
+    assert "version agreement passed: 0.1.3" in initial.stdout
+
+    durable_names = (
+        "AGENTS.md",
+        "ARCHITECTURE.md",
+        "COMPATIBILITY.md",
+        "CONTRIBUTING.md",
+        "README.md",
+    )
+    durable_before = {name: (releasable_documents / name).read_bytes() for name in durable_names}
+    _replace(releasable_documents, "pyproject.toml", "0.1.3", "0.1.4")
+    _replace(releasable_documents, ".release-please-manifest.json", "0.1.3", "0.1.4")
+    with (releasable_documents / "CHANGELOG.md").open("a", encoding="utf-8") as stream:
+        stream.write("\n## [0.1.4] - 2026-08-01\n\nPatch maintenance.\n")
+
+    result = subprocess.run(
+        command,
+        cwd=releasable_documents,
+        text=True,
+        check=False,
+        capture_output=True,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "version agreement passed: 0.1.4" in result.stdout
+    assert {
+        name: (releasable_documents / name).read_bytes() for name in durable_names
+    } == durable_before
+
+
+def test_version_cli_rejects_project_manifest_disagreement(
+    releasable_documents: Path,
+) -> None:
+    version_script = _copy_version_checker(releasable_documents)
+    _replace(releasable_documents, ".release-please-manifest.json", "0.1.0-alpha.1", "0.1.4")
+
+    result = subprocess.run(
+        [sys.executable, str(version_script), "--require-public-preview-docs"],
+        cwd=releasable_documents,
+        text=True,
+        check=False,
+        capture_output=True,
+    )
+
+    assert result.returncode != 0
+    assert "version disagreement" in result.stderr
+    assert "release-please manifest=0.1.4" in result.stderr
+
+
 @pytest.mark.parametrize(
     "replacement",
     [
@@ -258,6 +504,117 @@ def test_artifact_metadata_requires_unpinned_install_command() -> None:
         )
 
 
+def test_artifact_metadata_rejects_mutable_published_patch_claim() -> None:
+    description = (
+        "Stable 0.1.x maintenance releases are available from PyPI.\n"
+        "Latest stable version: `0.1.2`.\n"
+        f"{PUBLIC_README_INSTALL_COMMAND}"
+    )
+    with pytest.raises(
+        CheckError,
+        match="mutable latest/current published patch version",
+    ):
+        check_metadata(
+            _artifact_metadata(description),
+            "fixture:METADATA",
+            "0.1.0a1",
+            f"{description}\n",
+        )
+
+
+def test_wheel_rejects_mutable_claim_in_long_description(tmp_path: Path) -> None:
+    current_version = read_project_version()
+    built = tmp_path / "built-wheel"
+    subprocess.run(
+        ["uv", "build", "--wheel", "--out-dir", str(built)],
+        cwd=PROJECT_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    source = built / f"cometapi-{current_version}-py3-none-any.whl"
+    mutated = tmp_path / source.name
+    with zipfile.ZipFile(source) as archive, zipfile.ZipFile(mutated, mode="w") as output:
+        for info in archive.infolist():
+            content = archive.read(info.filename)
+            if info.filename.endswith(".dist-info/METADATA"):
+                content = content.replace(
+                    b"\n\n",
+                    b"\n\nLatest stable version: `0.1.2`.\n",
+                    1,
+                )
+            output.writestr(info, content)
+
+    with pytest.raises(CheckError) as caught:
+        check_wheel(
+            mutated,
+            current_version,
+            (PROJECT_ROOT / "README.md").read_text(encoding="utf-8"),
+        )
+
+    message = str(caught.value)
+    assert ".dist-info/METADATA" in message
+    assert "long description does not exactly match source README.md" in message
+
+
+def test_sdist_rejects_mutable_claim_in_persistent_document(tmp_path: Path) -> None:
+    current_version = read_project_version()
+    built = tmp_path / "built"
+    subprocess.run(
+        ["uv", "build", "--sdist", "--out-dir", str(built)],
+        cwd=PROJECT_ROOT,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    source = built / f"cometapi-{current_version}.tar.gz"
+    extracted = tmp_path / "extracted"
+    extracted.mkdir()
+    with tarfile.open(source, mode="r:gz") as archive:
+        members = archive.getmembers()
+        assert all(
+            not Path(member.name).is_absolute()
+            and ".." not in Path(member.name).parts
+            and not (member.issym() or member.islnk() or member.isdev())
+            for member in members
+        )
+        archive.extractall(extracted)
+    root = extracted / f"cometapi-{current_version}"
+    with (root / "AGENTS.md").open("a", encoding="utf-8") as stream:
+        stream.write("\nThe current PyPI release is `0.1.2`.\n")
+    mutated = tmp_path / f"cometapi-{current_version}.tar.gz"
+    with tarfile.open(mutated, mode="w:gz") as archive:
+        archive.add(root, arcname=root.name)
+
+    with pytest.raises(CheckError) as caught:
+        check_sdist(
+            mutated,
+            current_version,
+            (PROJECT_ROOT / "README.md").read_text(encoding="utf-8"),
+        )
+
+    message = str(caught.value)
+    assert "AGENTS.md:" in message
+    assert "mutable latest/current published patch version" in message
+    assert MUTABLE_PUBLISHED_VERSION_FIX in message
+
+
+def test_copied_repository_verification_runs_public_document_gate() -> None:
+    commands = check_repository_independence.offline_check_commands()
+
+    version_commands = [command for command in commands if "scripts/check_version.py" in command]
+    assert version_commands == [
+        [
+            "uv",
+            "run",
+            "python",
+            "scripts/check_version.py",
+            "--require-changelog",
+            "--require-public-preview-docs",
+        ]
+    ]
+
+
 def test_artifact_metadata_must_match_source_readme_exactly() -> None:
     expected = (
         "Stable 0.1.x maintenance releases are available from PyPI.\n"
diff --git a/tests/test_release_workflow.py b/tests/test_release_workflow.py
index 1a5cdc0..5f668b0 100644
--- a/tests/test_release_workflow.py
+++ b/tests/test_release_workflow.py
@@ -400,6 +400,24 @@ def test_current_publish_workflow_satisfies_semantic_contract() -> None:
     )
 
 
+@pytest.mark.parametrize(
+    "needle",
+    [
+        " --require-releasable-docs --print-version)",
+        " --require-releasable-docs dist/*",
+    ],
+    ids=["source-tag-gate", "artifact-version-gate"],
+)
+def test_publish_contract_requires_releasable_document_gate(needle: str) -> None:
+    text = PUBLISH_WORKFLOW.read_text(encoding="utf-8")
+    assert needle in text
+    with pytest.raises(RuntimeError):
+        check_publish_workflow(
+            text.replace(needle, needle.replace(" --require-releasable-docs", ""), 1),
+            LIVE_SMOKE_WORKFLOW.read_text(encoding="utf-8"),
+        )
+
+
 def test_release_please_uses_split_node24_v5_execution() -> None:
     text = RELEASE_PLEASE_WORKFLOW.read_text(encoding="utf-8")
     action = (
@@ -1319,8 +1337,9 @@ def test_ci_contract_rejects_extra_skip_dependency_job() -> None:
     "needle",
     [
         "      - name: Check lock consistency\n        run: uv lock --check\n",
-        "      - name: Check canonical public content and identity\n"
-        "        run: uv run python scripts/check_version.py --require-public-preview-docs\n",
+        "      - name: Check version agreement and durable public content\n"
+        "        run: uv run python scripts/check_version.py --require-changelog "
+        "--require-public-preview-docs\n",
         "      - name: Verify from a copied standalone repository\n"
         "        run: python scripts/check_repository_independence.py\n",
         "      - name: Recheck retained artifact digests\n"
@@ -1337,9 +1356,11 @@ def test_ci_contract_rejects_missing_private_validation_gate(needle: str) -> Non
 
 def test_ci_contract_rejects_commented_public_content_decoy() -> None:
     text = CI_WORKFLOW.read_text(encoding="utf-8").replace(
-        "      - name: Check canonical public content and identity\n"
-        "        run: uv run python scripts/check_version.py --require-public-preview-docs\n",
-        "      # run: uv run python scripts/check_version.py --require-public-preview-docs\n",
+        "      - name: Check version agreement and durable public content\n"
+        "        run: uv run python scripts/check_version.py --require-changelog "
+        "--require-public-preview-docs\n",
+        "      # run: uv run python scripts/check_version.py --require-changelog "
+        "--require-public-preview-docs\n",
         1,
     )
     with pytest.raises(RuntimeError, match="public-preview-docs"):