blun-king-cli 9.1.597 → 9.1.600

package/standard-skills/translate-native/integrations/website_localization_cms.py

@@ -31,9 +31,9 @@ PUBLICATION_SCHEMA = "blun.cms-localization-publication.v3"
 ACK_SCHEMA = "blun.cms-localization-publication-ack.v1"
 TOMBSTONE_DELIVERY_SCHEMA = "blun.cms-localization-tombstone.v1"
 TOMBSTONE_ACK_SCHEMA = "blun.cms-localization-tombstone-ack.v1"
-CAPABILITIES_SCHEMA = "blun.website-localization-capabilities.v3"
+CAPABILITIES_SCHEMA = "blun.website-localization-capabilities.v9"
 PUBLICATION_HTTP_CONTRACT_SCHEMA = (
-    "blun.cms-localization-publication-http-capabilities.v2"
+    "blun.cms-localization-publication-http-capabilities.v5"
 )
 PUBLICATION_HTTP_REQUEST_SCHEMA = "blun.cms-localization-publication-http.v1"
 PUBLICATION_HTTP_RESPONSE_SCHEMA = "blun.cms-localization-publication-http-ack.v1"
@@ -382,9 +382,15 @@ def _valid_release_evidence(
     locale: Any,
     target_sha256: Any,
     approval_id: Any,
+    require_current_locale_quality: bool = True,
 ) -> bool:
     try:
-        evidence = _RELEASE.validate_publication_evidence(value)
+        evidence = _RELEASE.validate_publication_evidence(
+            value,
+            require_current_locale_quality=(
+                require_current_locale_quality
+            ),
+        )
     except _RELEASE.LocalizationReleaseBlocked:
         return False
     return (
@@ -507,32 +513,229 @@ class WebsiteLocalizationCMSBridge:
                 raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
 
             commercial = _COMMERCIAL.public_profile(_PLANNER.COMMERCIAL_PROFILE)
+            rendering_registry = _PLANNER.commercial_rendering_registry()
+            review_evidence_contract = (
+                _COMMERCIAL.public_review_evidence_contract(
+                    _PLANNER.COMMERCIAL_PROFILE,
+                )
+            )
             review_summary_contract = _COMMERCIAL.public_review_summary_contract(
                 _PLANNER.COMMERCIAL_PROFILE,
             )
+            review_routing_contract = (
+                _COMMERCIAL.public_review_routing_contract(
+                    _PLANNER.COMMERCIAL_PROFILE,
+                )
+            )
+            review_resolution_contract = (
+                _COMMERCIAL.public_review_resolution_contract(
+                    _PLANNER.COMMERCIAL_PROFILE,
+                )
+            )
             if (
                 not isinstance(commercial, dict)
                 or set(commercial) != {
                     "schema", "profile", "applies_to", "dimensions",
                     "preservation", "rendering", "verification",
-                    "protected_terms", "review_summary_schema",
-                    "review_summary_contract", "sha256",
+                    "locale_quality_profile", "protected_terms",
+                    "review_evidence_schema", "review_evidence_contract",
+                    "review_summary_schema",
+                    "review_summary_contract", "review_routing_schema",
+                    "review_routing_contract", "review_resolution_schema",
+                    "review_resolution_contract", "sha256",
                 }
                 or commercial["schema"] != _COMMERCIAL.PUBLIC_PROFILE_SCHEMA
                 or commercial["profile"] != _PLANNER.COMMERCIAL_PROFILE
+                or commercial["review_evidence_schema"]
+                != _PLANNER.COMMERCIAL_PROFILE
+                or commercial["review_evidence_contract"]
+                != review_evidence_contract
                 or commercial["review_summary_schema"]
                 != _COMMERCIAL.REVIEW_SUMMARY_SCHEMA
                 or commercial["review_summary_contract"] != review_summary_contract
+                or commercial["review_routing_schema"]
+                != _COMMERCIAL.REVIEW_ROUTING_SCHEMA
+                or commercial["review_routing_contract"]
+                != review_routing_contract
+                or commercial["review_resolution_schema"]
+                != _COMMERCIAL.REVIEW_RESOLUTION_SCHEMA
+                or commercial["review_resolution_contract"]
+                != review_resolution_contract
                 or commercial["applies_to"] != {
                     "content_type": "commercial",
                     "locales": "all-supported-target-locales",
                 }
                 or commercial["protected_terms"] != "project-configuration-only"
+                or commercial["locale_quality_profile"] != {
+                    "schema": _COMMERCIAL.COMMERCIAL_LOCALE_PROFILE_SCHEMA,
+                    "required": True,
+                    "binding_fields": [
+                        "locale", "version", "commercial_profile",
+                        "quality_profile_version", "quality_profile_sha256",
+                        "rendering_reference",
+                        "sha256",
+                    ],
+                    "rendering_reference": {
+                        "schema": (
+                            _COMMERCIAL.COMMERCIAL_RENDERING_REFERENCE_SCHEMA
+                        ),
+                        "authority": "Unicode CLDR",
+                        "version": "48",
+                        "purpose": "target-locale-rendering-guidance",
+                        "semantic_proof": False,
+                        "unresolved_route": (
+                            "independent-model-or-qualified-native-domain-review"
+                        ),
+                    },
+                    "required_commercial_checks": list(
+                        _EXPECTED_COMMERCIAL_DIMENSIONS
+                    ),
+                    "provider_phases": [
+                        "transcreation", "target_native", "source_fidelity",
+                    ],
+                    "tamper_policy": "block-before-provider",
+                }
                 or [item.get("name") for item in commercial["dimensions"]]
                 != list(_EXPECTED_COMMERCIAL_DIMENSIONS)
                 or tuple(_COMMERCIAL.DIMENSIONS) != _EXPECTED_COMMERCIAL_DIMENSIONS
             ):
                 raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
+            unsigned_review_evidence_contract = dict(
+                review_evidence_contract
+            )
+            review_evidence_digest = unsigned_review_evidence_contract.pop(
+                "sha256", None,
+            )
+            if (
+                set(review_evidence_contract) != {
+                    "schema", "result_schema", "profile", "required_fields",
+                    "coverage", "offer_registry", "checks", "trust_boundary",
+                    "content_policy", "sha256",
+                }
+                or review_evidence_contract["schema"]
+                != _COMMERCIAL.REVIEW_EVIDENCE_CAPABILITIES_SCHEMA
+                or review_evidence_contract["result_schema"]
+                != _PLANNER.COMMERCIAL_PROFILE
+                or review_evidence_contract["profile"]
+                != _PLANNER.COMMERCIAL_PROFILE
+                or review_evidence_contract["required_fields"] != [
+                    "schema", "coverage", "offers", "checks",
+                ]
+                or review_evidence_contract["coverage"] != {
+                    "allowed": ["complete", "uncertain"],
+                    "complete": (
+                        "every-proposition-and-offer-association-reviewed"
+                    ),
+                    "uncertain": "independent-review-required",
+                }
+                or review_evidence_contract["offer_registry"] != {
+                    "field": "offers",
+                    "max_items": 1000,
+                    "item_required_fields": [
+                        "id", "source_spans", "target_spans",
+                    ],
+                    "identifier": {
+                        "pattern": r"^[A-Za-z0-9_.:-]{1,256}$",
+                        "unique": True,
+                    },
+                    "regions": {
+                        "fields": ["source_spans", "target_spans"],
+                        "span_format": (
+                            "zero-based-unicode-code-points-exclusive-end"
+                        ),
+                        "non_empty_text": True,
+                        "ordered": True,
+                        "overlap": "forbidden-within-and-across-offers",
+                        "discontiguous": True,
+                        "at_least_one_side_non_empty": True,
+                    },
+                }
+                or review_evidence_contract["checks"] != {
+                    "required_dimensions": list(
+                        _EXPECTED_COMMERCIAL_DIMENSIONS
+                    ),
+                    "exact_dimension_set": True,
+                    "max_items_per_dimension": 1000,
+                    "statuses": [
+                        "equivalent", "not_present", "changed", "uncertain",
+                    ],
+                    "status_items": {
+                        "equivalent": "one-or-more-matched",
+                        "not_present": "empty",
+                        "changed": "one-or-more-specific",
+                        "uncertain": "one-or-more-specific",
+                    },
+                    "offer_statuses": {
+                        "field": "offer_statuses",
+                        "item_required_fields": ["offer", "status"],
+                        "coverage": "exactly-one-per-registered-offer",
+                        "order": "offer-registry-order",
+                        "statuses": [
+                            "equivalent", "not_present", "changed",
+                            "uncertain",
+                        ],
+                        "global_status": (
+                            "changed-then-uncertain-then-equivalent-then-"
+                            "not_present"
+                        ),
+                        "items_must_match_offer_status": True,
+                    },
+                    "item": {
+                        "required_fields": [
+                            "offer", "relation", "source_span", "target_span",
+                            "explanation",
+                        ],
+                        "offer": "registered-offer-id",
+                        "relations": [
+                            "matched", "source_only", "target_only",
+                        ],
+                        "matched_requires": "source-and-target-spans",
+                        "source_only_requires": (
+                            "source-span-and-null-target-span"
+                        ),
+                        "target_only_requires": (
+                            "null-source-span-and-target-span"
+                        ),
+                        "span_containment": "inside-named-offer-region",
+                        "duplicates": "forbidden-per-dimension",
+                        "explanation": (
+                            "non-empty-maximum-2000-code-points"
+                        ),
+                    },
+                    "offer_assignment": {
+                        "equivalent": (
+                            "exactly-one-matched-item-per-registered-offer"
+                        ),
+                        "other_equivalent_checks_require_equivalent_assignment": (
+                            True
+                        ),
+                    },
+                }
+                or review_evidence_contract["trust_boundary"] != {
+                    "validates": "structure-offsets-and-verdict-consistency",
+                    "semantic_truth": False,
+                    "numeric_regex_semantic_proof": False,
+                    "unresolved_route": (
+                        "independent-model-or-qualified-native-domain-review"
+                    ),
+                    "publication_authority": False,
+                }
+                or review_evidence_contract["content_policy"] != {
+                    "source_text": False,
+                    "target_text": False,
+                    "source_spans": False,
+                    "target_spans": False,
+                    "reviewer_prose": False,
+                    "project_prices": False,
+                    "project_brands": False,
+                }
+                or not isinstance(review_evidence_digest, str)
+                or SHA256.fullmatch(review_evidence_digest) is None
+                or review_evidence_digest != _hash(
+                    _canonical_json(unsigned_review_evidence_contract)
+                )
+            ):
+                raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
             unsigned_review_summary_contract = dict(review_summary_contract)
             review_summary_digest = unsigned_review_summary_contract.pop(
                 "sha256", None,
@@ -540,8 +743,10 @@ class WebsiteLocalizationCMSBridge:
             if (
                 set(review_summary_contract) != {
                     "schema", "result_schema", "profile", "required_fields",
-                    "statuses", "review_required_dimensions", "evidence_sha256",
-                    "content_policy", "sha256",
+                    "statuses", "review_required_dimensions",
+                    "offer_count", "review_required_offers", "evidence_sha256",
+                    "review_evidence_contract_sha256", "content_policy",
+                    "sha256",
                 }
                 or review_summary_contract["schema"]
                 != _COMMERCIAL.REVIEW_SUMMARY_CAPABILITIES_SCHEMA
@@ -551,12 +756,17 @@ class WebsiteLocalizationCMSBridge:
                 != _PLANNER.COMMERCIAL_PROFILE
                 or review_summary_contract["required_fields"] != [
                     "schema", "profile", "status", "review_required_dimensions",
-                    "evidence_sha256",
+                    "offer_count", "review_required_offers",
+                    "review_evidence_contract_sha256", "evidence_sha256",
                 ]
                 or review_summary_contract["statuses"] != {
-                    "verified": {"review_required_dimensions": "empty"},
+                    "verified": {
+                        "review_required_dimensions": "empty",
+                        "review_required_offers": "empty",
+                    },
                     "review_required": {
                         "review_required_dimensions": "one-or-more",
+                        "review_required_offers": "zero-or-more",
                         "requires_independent_review": True,
                     },
                 }
@@ -565,12 +775,63 @@ class WebsiteLocalizationCMSBridge:
                     "order": list(_EXPECTED_COMMERCIAL_DIMENSIONS),
                     "unique": True,
                 }
+                or review_summary_contract["review_required_offers"] != {
+                    "item_required_fields": [
+                        "dimension", "offer_indexes",
+                    ],
+                    "dimension_order": list(
+                        _EXPECTED_COMMERCIAL_DIMENSIONS
+                    ),
+                    "dimension_must_be_review_required": True,
+                    "offer_indexes": {
+                        "meaning": (
+                            "zero-based-opaque-offer-registry-position"
+                        ),
+                        "minimum": 0,
+                        "maximum_exclusive": 1000,
+                        "order": "ascending",
+                        "unique": True,
+                    },
+                    "configured_offer_identifiers_published": False,
+                }
+                or review_summary_contract["offer_count"] != {
+                    "meaning": "opaque-offer-registry-size",
+                    "minimum": 0,
+                    "maximum": 1000,
+                }
                 or review_summary_contract["evidence_sha256"] != {
                     "algorithm": "sha-256",
                     "canonicalization": (
                         "utf-8-json-sort-keys-no-insignificant-whitespace"
                     ),
-                    "covers": "complete-commercial-review-evidence",
+                    "binding_schema": _COMMERCIAL.EVIDENCE_BINDING_SCHEMA,
+                    "binding_fields": [
+                        "schema", "profile",
+                        "review_evidence_contract_sha256", "target_locale",
+                        "commercial_quality_profile_version",
+                        "commercial_quality_profile_sha256", "source_sha256",
+                        "target_sha256", "evidence",
+                    ],
+                    "text_hashing": "exact-utf-8",
+                    "covers": [
+                        "commercial-profile",
+                        "exact-review-evidence-contract",
+                        "exact-target-locale",
+                        "commercial-quality-profile-generation",
+                        "exact-source-sha256",
+                        "exact-target-sha256",
+                        "offer-registry-and-proposition-assignment",
+                        "complete-commercial-review-evidence",
+                    ],
+                }
+                or review_summary_contract[
+                    "review_evidence_contract_sha256"
+                ] != {
+                    "algorithm": "sha-256",
+                    "equals": review_evidence_contract["sha256"],
+                    "purpose": (
+                        "reject-stale-or-reinterpreted-private-evidence"
+                    ),
                 }
                 or review_summary_contract["content_policy"] != {
                     "source_text": False,
@@ -587,6 +848,183 @@ class WebsiteLocalizationCMSBridge:
                 != _hash(_canonical_json(unsigned_review_summary_contract))
             ):
                 raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
+            unsigned_review_routing_contract = dict(
+                review_routing_contract
+            )
+            review_routing_digest = unsigned_review_routing_contract.pop(
+                "sha256", None,
+            )
+            if (
+                set(review_routing_contract) != {
+                    "schema", "result_schema", "profile", "applies_when",
+                    "required_fields", "text_lengths", "offers",
+                    "trust_boundary", "content_policy", "sha256",
+                }
+                or review_routing_contract["schema"]
+                != _COMMERCIAL.REVIEW_ROUTING_CAPABILITIES_SCHEMA
+                or review_routing_contract["result_schema"]
+                != _COMMERCIAL.REVIEW_ROUTING_SCHEMA
+                or review_routing_contract["profile"]
+                != _PLANNER.COMMERCIAL_PROFILE
+                or review_routing_contract["applies_when"] != {
+                    "review_summary_status": "review_required",
+                    "offer_count": "exact-review-summary-offer-count",
+                }
+                or review_routing_contract["required_fields"] != [
+                    "schema", "profile", "contract_sha256", "offer_count",
+                    "source_length", "target_length", "offers",
+                ]
+                or review_routing_contract["text_lengths"] != {
+                    "fields": ["source_length", "target_length"],
+                    "unit": "unicode-code-points",
+                    "must_equal_complete_texts": True,
+                }
+                or review_routing_contract["offers"] != {
+                    "coverage": "exactly-one-per-registered-offer",
+                    "order": "offer-registry-order",
+                    "item_required_fields": [
+                        "offer_index", "source_spans", "target_spans",
+                    ],
+                    "offer_index": {
+                        "meaning": (
+                            "zero-based-opaque-offer-registry-position"
+                        ),
+                        "minimum": 0,
+                        "maximum_exclusive": 1000,
+                        "order": "ascending",
+                        "unique": True,
+                    },
+                    "regions": {
+                        "fields": ["source_spans", "target_spans"],
+                        "span_format": (
+                            "zero-based-unicode-code-points-exclusive-end"
+                        ),
+                        "non_empty_text": True,
+                        "ordered": True,
+                        "overlap": "forbidden-within-and-across-offers",
+                        "discontiguous": True,
+                        "at_least_one_side_non_empty": True,
+                    },
+                }
+                or review_routing_contract["trust_boundary"] != {
+                    "validates": (
+                        "shape-offsets-order-count-and-text-lengths"
+                    ),
+                    "semantic_truth": False,
+                    "route_values": (
+                        "private-evidence-and-receipt-boundary-only"
+                    ),
+                    "public_release_evidence": False,
+                    "publication_authority": False,
+                }
+                or review_routing_contract["content_policy"] != {
+                    "configured_offer_identifiers": False,
+                    "source_text": False,
+                    "target_text": False,
+                    "reviewer_prose": False,
+                    "project_prices": False,
+                    "project_brands": False,
+                }
+                or not isinstance(review_routing_digest, str)
+                or SHA256.fullmatch(review_routing_digest) is None
+                or review_routing_digest != _hash(
+                    _canonical_json(unsigned_review_routing_contract)
+                )
+            ):
+                raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
+            unsigned_review_resolution_contract = dict(
+                review_resolution_contract
+            )
+            review_resolution_digest = (
+                unsigned_review_resolution_contract.pop("sha256", None)
+            )
+            if (
+                set(review_resolution_contract) != {
+                    "schema", "result_schema", "profile", "applies_when",
+                    "required_fields", "status", "methods",
+                    "provider_identity", "reviewed_dimensions",
+                    "reviewed_offer_count", "reviewed_offers",
+                    "receipt_sha256",
+                    "content_policy", "sha256",
+                }
+                or review_resolution_contract["schema"]
+                != _COMMERCIAL.REVIEW_RESOLUTION_CAPABILITIES_SCHEMA
+                or review_resolution_contract["result_schema"]
+                != _COMMERCIAL.REVIEW_RESOLUTION_SCHEMA
+                or review_resolution_contract["profile"]
+                != _PLANNER.COMMERCIAL_PROFILE
+                or review_resolution_contract["applies_when"] != {
+                    "review_summary_status": "review_required",
+                    "reviewed_dimensions": (
+                        "exact-ordered-review-summary-dimensions"
+                    ),
+                    "reviewed_offer_count": (
+                        "exact-review-summary-offer-count"
+                    ),
+                    "reviewed_offers": (
+                        "exact-ordered-review-summary-offer-scope"
+                    ),
+                }
+                or review_resolution_contract["required_fields"] != [
+                    "schema", "profile", "contract_sha256", "status",
+                    "reviewed_dimensions", "reviewed_offer_count",
+                    "reviewed_offers", "method",
+                    "receipt_sha256",
+                    "primary_provider", "provider",
+                ]
+                or review_resolution_contract["status"] != "resolved"
+                or review_resolution_contract["methods"] != {
+                    "qualified_human": {
+                        "primary_provider": "required",
+                        "provider": "null",
+                        "receipt": "verified-qualified-human-review",
+                    },
+                    "independent_model": {
+                        "primary_provider": "required",
+                        "provider": "required",
+                        "provider_id_must_differ_from_primary_provider": True,
+                        "receipt": "verified-independent-model-review",
+                    },
+                }
+                or review_resolution_contract["provider_identity"] != {
+                    "fields": ["id", "model_id", "model_version"],
+                    "primary_provider": "required",
+                    "credentials_published": False,
+                }
+                or review_resolution_contract["reviewed_dimensions"] != {
+                    "allowed": list(_EXPECTED_COMMERCIAL_DIMENSIONS),
+                    "order": list(_EXPECTED_COMMERCIAL_DIMENSIONS),
+                    "unique": True,
+                    "must_equal_review_summary": True,
+                }
+                or review_resolution_contract["reviewed_offers"] != {
+                    "must_equal_review_summary": True,
+                    "configured_offer_identifiers_published": False,
+                }
+                or review_resolution_contract["reviewed_offer_count"] != {
+                    "must_equal_review_summary": True,
+                }
+                or review_resolution_contract["receipt_sha256"] != {
+                    "algorithm": "sha-256",
+                    "covers": "exact-verified-review-receipt",
+                    "raw_receipt_published": False,
+                }
+                or review_resolution_contract["content_policy"] != {
+                    "source_text": False,
+                    "target_text": False,
+                    "raw_receipt": False,
+                    "reviewer_prose": False,
+                    "qualified_human_identity": False,
+                    "project_prices": False,
+                    "project_brands": False,
+                }
+                or not isinstance(review_resolution_digest, str)
+                or SHA256.fullmatch(review_resolution_digest) is None
+                or review_resolution_digest != _hash(
+                    _canonical_json(unsigned_review_resolution_contract)
+                )
+            ):
+                raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
             unsigned_commercial = dict(commercial)
             commercial_digest = unsigned_commercial.pop("sha256", None)
             if (
@@ -597,6 +1035,7 @@ class WebsiteLocalizationCMSBridge:
                 raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
 
             locales = []
+            expected_rendering_locales = []
             seen_locales: set[str] = set()
             seen_languages: set[str] = set()
             seen_eu_codes: set[str] = set()
@@ -638,11 +1077,28 @@ class WebsiteLocalizationCMSBridge:
                 ):
                     raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
                 quality = _PLANNER.quality_profile_for(locale)
+                commercial_quality = _PLANNER.commercial_quality_profile_for(
+                    locale,
+                )
                 if (
                     not isinstance(quality, dict)
                     or quality.get("locale") != locale
                     or quality.get("version") != version
                     or quality.get("sha256") != digest
+                    or not isinstance(commercial_quality, dict)
+                    or commercial_quality.get("locale") != locale
+                    or commercial_quality.get("commercial_profile")
+                    != _PLANNER.COMMERCIAL_PROFILE
+                    or commercial_quality.get("quality_profile_version")
+                    != version
+                    or commercial_quality.get("quality_profile_sha256")
+                    != digest
+                    or commercial_quality.get("schema")
+                    != _COMMERCIAL.COMMERCIAL_LOCALE_PROFILE_SCHEMA
+                    or not isinstance(commercial_quality.get("version"), str)
+                    or TOKEN.fullmatch(commercial_quality["version"]) is None
+                    or not isinstance(commercial_quality.get("sha256"), str)
+                    or SHA256.fullmatch(commercial_quality["sha256"]) is None
                 ):
                     raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
                 seen_locales.add(locale)
@@ -657,8 +1113,47 @@ class WebsiteLocalizationCMSBridge:
                     "direction": direction,
                     "quality_profile_version": version,
                     "quality_profile_sha256": digest,
+                    "commercial_quality_profile_version": (
+                        commercial_quality["version"]
+                    ),
+                    "commercial_quality_profile_sha256": (
+                        commercial_quality["sha256"]
+                    ),
+                })
+                expected_rendering_locales.append({
+                    "locale": locale,
+                    "commercial_quality_profile": {
+                        "version": commercial_quality["version"],
+                        "sha256": commercial_quality["sha256"],
+                    },
+                    "rendering_reference": commercial_quality[
+                        "rendering_reference"
+                    ],
                 })
 
+            expected_rendering_registry = {
+                "schema": _PLANNER.COMMERCIAL_RENDERING_REGISTRY_SCHEMA,
+                "commercial_profile": _PLANNER.COMMERCIAL_PROFILE,
+                "source": {
+                    "authority": "Unicode CLDR",
+                    "version": "48",
+                },
+                "content_policy": {
+                    "source_text": False,
+                    "target_text": False,
+                    "project_prices": False,
+                    "project_brands": False,
+                    "credentials": False,
+                },
+                "locales": expected_rendering_locales,
+            }
+            expected_rendering_registry = {
+                **expected_rendering_registry,
+                "sha256": _hash(_canonical_json(expected_rendering_registry)),
+            }
+            if rendering_registry != expected_rendering_registry:
+                raise CMSBridgeBlocked("cms.capabilities.registry_invalid")
+
             body = {
                 "schema": CAPABILITIES_SCHEMA,
                 "change_schema": CHANGE_SCHEMA,
@@ -677,6 +1172,7 @@ class WebsiteLocalizationCMSBridge:
                 "content_types": sorted(content_types),
                 "quality_passes": list(quality_passes),
                 "commercial_profile": commercial,
+                "commercial_rendering_registry": rendering_registry,
                 "publication_http": self._publication_http_capabilities(),
                 "locales": locales,
             }
@@ -691,6 +1187,11 @@ class WebsiteLocalizationCMSBridge:
     def _publication_http_capabilities() -> dict[str, Any]:
         """Describe the built-in outbound adapter without deployment secrets."""
         try:
+            release_evidence_contract = (
+                _RELEASE.validate_publication_evidence_contract(
+                    _RELEASE.publication_evidence_contract()
+                )
+            )
             operations = [
                 {
                     "name": "publication",
@@ -783,6 +1284,7 @@ class WebsiteLocalizationCMSBridge:
                     _RELEASE.PUBLICATION_EVIDENCE_SCHEMA,
                     "cms.capabilities.registry_invalid",
                 ),
+                "release_evidence_contract": release_evidence_contract,
                 "binding_headers": headers,
                 "health_binding_headers": [
                     {