blun-king-cli 9.1.597 → 9.1.600

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

@@ -21,15 +21,30 @@ from typing import Any, Iterator, Protocol
 
 
 SCHEMA_VERSION = 1
-APPROVAL_SCHEMA = "blun.website-localization-approval.v3"
-RECEIPT_BINDING_SCHEMA = "blun.localization-quality-receipt-binding.v2"
+APPROVAL_SCHEMA = "blun.website-localization-approval.v10"
+RECEIPT_BINDING_SCHEMA = "blun.localization-quality-receipt-binding.v9"
 INDEPENDENT_MODEL_REVIEW_SCHEMA = "blun.independent-model-review.v1"
-PUBLICATION_EVIDENCE_SCHEMA = "blun.website-localization-release-evidence.v1"
+PUBLICATION_EVIDENCE_SCHEMA = "blun.website-localization-release-evidence.v14"
+PUBLICATION_EVIDENCE_CAPABILITIES_SCHEMA = (
+    "blun.website-localization-release-evidence-capabilities.v8"
+)
+PUBLICATION_EVIDENCE_FIELDS = (
+    "schema", "release_evidence_contract_sha256", "job_id", "target_locale",
+    "target_sha256", "approval_id",
+    "content_type", "result_sha256", "approval_sha256",
+    "quality_receipt_sha256", "evidence_request_id", "evidence_revision",
+    "quality_profile",
+    "commercial_profile", "commercial_quality_profile", "commercial_review",
+    "commercial_review_routing_contract_sha256",
+    "commercial_review_resolution_contract_sha256",
+    "commercial_review_resolution",
+)
 MAX_TEXT_BYTES = 2_000_000
 MAX_RECEIPT_LENGTH = 16_384
 MAX_TTL_SECONDS = 31_536_000.0
 HEX64 = re.compile(r"^[0-9a-f]{64}$")
 TOKEN = re.compile(r"^[A-Za-z0-9_.:-]{1,256}$")
+EVIDENCE_REQUEST_ID = re.compile(r"^blun-l10n-evidence-[0-9a-f]{64}$")
 _COLUMNS = (
     "approval_id", "job_id", "target_locale", "target_sha256",
     "result_json", "result_sha256", "approval_json", "approval_sha256",
@@ -56,6 +71,9 @@ _WORKER = _load_module(
     "blun_website_localization_release_worker",
     _ROOT / "integrations" / "website_localization_worker.py",
 )
+COMMERCIAL_REVIEW_RESOLUTION_SCHEMA = (
+    _WORKER._COMMERCIAL.REVIEW_RESOLUTION_SCHEMA
+)
 
 
 class LocalizationReleaseBlocked(RuntimeError):
@@ -122,17 +140,23 @@ class WebsiteReadiness:
     blocked: tuple[tuple[str, str], ...]
 
 
-def validate_publication_evidence(value: Any) -> dict[str, Any]:
+def validate_publication_evidence(
+    value: Any,
+    *,
+    require_current_locale_quality: bool = True,
+) -> dict[str, Any]:
     """Validate the content-free release proof carried to a CMS."""
 
-    if not isinstance(value, dict) or set(value) != {
-        "schema", "job_id", "target_locale", "target_sha256", "approval_id",
-        "content_type", "result_sha256", "approval_sha256",
-        "quality_receipt_sha256", "commercial_profile", "commercial_review",
-    }:
+    if (
+        not isinstance(require_current_locale_quality, bool)
+        or not isinstance(value, dict)
+        or set(value) != set(PUBLICATION_EVIDENCE_FIELDS)
+    ):
         raise LocalizationReleaseBlocked("publication.evidence.invalid")
     if (
         value.get("schema") != PUBLICATION_EVIDENCE_SCHEMA
+        or value.get("release_evidence_contract_sha256")
+        != publication_evidence_contract()["sha256"]
         or any(
             not isinstance(value.get(field), str)
             or TOKEN.fullmatch(value[field]) is None
@@ -145,18 +169,111 @@ def validate_publication_evidence(value: Any) -> dict[str, Any]:
                 "quality_receipt_sha256",
             )
         )
+        or not isinstance(value.get("evidence_request_id"), str)
+        or EVIDENCE_REQUEST_ID.fullmatch(value["evidence_request_id"]) is None
+        or not isinstance(value.get("evidence_revision"), str)
+        or TOKEN.fullmatch(value["evidence_revision"]) is None
     ):
         raise LocalizationReleaseBlocked("publication.evidence.invalid")
+    quality_profile = value.get("quality_profile")
+    if (
+        not isinstance(quality_profile, dict)
+        or set(quality_profile) != {"locale", "version", "sha256"}
+        or quality_profile.get("locale") != value["target_locale"]
+        or not isinstance(quality_profile.get("version"), str)
+        or TOKEN.fullmatch(quality_profile["version"]) is None
+        or HEX64.fullmatch(str(quality_profile.get("sha256"))) is None
+    ):
+        raise LocalizationReleaseBlocked("publication.evidence.invalid")
+    if require_current_locale_quality:
+        try:
+            current_quality = _WORKER._PLANNER.quality_profile_for(
+                value["target_locale"],
+            )
+            expected_quality_profile = {
+                "locale": current_quality["locale"],
+                "version": current_quality["version"],
+                "sha256": current_quality["sha256"],
+            }
+        except Exception:
+            raise LocalizationReleaseBlocked(
+                "publication.evidence.invalid"
+            ) from None
+        if quality_profile != expected_quality_profile:
+            raise LocalizationReleaseBlocked("publication.evidence.invalid")
     profile = value.get("commercial_profile")
+    commercial_quality_profile = value.get("commercial_quality_profile")
     review = value.get("commercial_review")
+    routing_contract_sha256 = value.get(
+        "commercial_review_routing_contract_sha256"
+    )
+    resolution_contract_sha256 = value.get(
+        "commercial_review_resolution_contract_sha256"
+    )
+    resolution = value.get("commercial_review_resolution")
     if (
-        (profile is None) != (review is None)
+        len({
+            profile is None,
+            commercial_quality_profile is None,
+            review is None,
+        }) != 1
+        or (profile is None) != (routing_contract_sha256 is None)
+        or (profile is None) != (resolution_contract_sha256 is None)
         or (value["content_type"] == "commercial") != (profile is not None)
     ):
         raise LocalizationReleaseBlocked("publication.evidence.invalid")
     if profile is not None:
         if not isinstance(profile, str) or TOKEN.fullmatch(profile) is None:
             raise LocalizationReleaseBlocked("publication.evidence.invalid")
+        expected_commercial_quality = None
+        if require_current_locale_quality:
+            try:
+                current_commercial_quality = (
+                    _WORKER._PLANNER.commercial_quality_profile_for(
+                        value["target_locale"],
+                    )
+                )
+                expected_commercial_quality = {
+                    "profile": current_commercial_quality[
+                        "commercial_profile"
+                    ],
+                    "version": current_commercial_quality["version"],
+                    "sha256": current_commercial_quality["sha256"],
+                }
+            except Exception:
+                raise LocalizationReleaseBlocked(
+                    "publication.evidence.invalid"
+                ) from None
+        if (
+            profile != _WORKER._PLANNER.COMMERCIAL_PROFILE
+            or (
+                require_current_locale_quality
+                and commercial_quality_profile != expected_commercial_quality
+            )
+            or HEX64.fullmatch(str(routing_contract_sha256)) is None
+            or routing_contract_sha256
+            != _WORKER._COMMERCIAL.public_review_routing_contract(profile)[
+                "sha256"
+            ]
+            or HEX64.fullmatch(str(resolution_contract_sha256)) is None
+            or resolution_contract_sha256
+            != _WORKER._COMMERCIAL.public_review_resolution_contract(profile)[
+                "sha256"
+            ]
+        ):
+            raise LocalizationReleaseBlocked("publication.evidence.invalid")
+        if (
+            not isinstance(commercial_quality_profile, dict)
+            or set(commercial_quality_profile)
+            != {"profile", "version", "sha256"}
+            or commercial_quality_profile.get("profile") != profile
+            or not isinstance(commercial_quality_profile.get("version"), str)
+            or TOKEN.fullmatch(commercial_quality_profile["version"]) is None
+            or HEX64.fullmatch(
+                str(commercial_quality_profile.get("sha256"))
+            ) is None
+        ):
+            raise LocalizationReleaseBlocked("publication.evidence.invalid")
         try:
             review = _WORKER._COMMERCIAL.validate_summary(
                 review,
@@ -168,7 +285,64 @@ def validate_publication_evidence(value: Any) -> dict[str, Any]:
             )
         except _WORKER._COMMERCIAL.CommercialReviewBlocked:
             raise LocalizationReleaseBlocked("publication.evidence.invalid") from None
-    return json.loads(_canonical_json({**value, "commercial_review": review}))
+        if review["status"] == "verified":
+            if resolution is not None:
+                raise LocalizationReleaseBlocked("publication.evidence.invalid")
+        else:
+            try:
+                resolution = _WORKER._COMMERCIAL.validate_review_resolution(
+                    resolution, review, profile,
+                )
+            except _WORKER._COMMERCIAL.CommercialReviewBlocked:
+                raise LocalizationReleaseBlocked("publication.evidence.invalid")
+    elif resolution is not None:
+        raise LocalizationReleaseBlocked("publication.evidence.invalid")
+    return json.loads(_canonical_json({
+        **value,
+        "commercial_review": review,
+        "commercial_review_resolution": resolution,
+    }))
+
+
+def _commercial_review_resolution(
+    result: dict[str, Any],
+    approval: dict[str, Any],
+) -> dict[str, Any] | None:
+    review = result["commercial_review"]
+    if (
+        result["content_type"] != "commercial"
+        or review["status"] == "verified"
+    ):
+        return None
+    human_receipt_sha256 = approval["human_review_receipt_sha256"]
+    independent = approval["independent_model_review"]
+    if human_receipt_sha256 is not None:
+        method = "qualified_human"
+        receipt_sha256 = human_receipt_sha256
+        provider = None
+    else:
+        method = "independent_model"
+        receipt_sha256 = independent["receipt_sha256"]
+        provider = json.loads(_canonical_json(independent["provider"]))
+    return {
+        "schema": COMMERCIAL_REVIEW_RESOLUTION_SCHEMA,
+        "profile": review["profile"],
+        "contract_sha256": approval[
+            "commercial_review_resolution_contract_sha256"
+        ],
+        "status": "resolved",
+        "reviewed_dimensions": json.loads(_canonical_json(
+            review["review_required_dimensions"]
+        )),
+        "reviewed_offer_count": review["offer_count"],
+        "reviewed_offers": json.loads(_canonical_json(
+            review["review_required_offers"]
+        )),
+        "method": method,
+        "receipt_sha256": receipt_sha256,
+        "primary_provider": json.loads(_canonical_json(result["provider"])),
+        "provider": provider,
+    }
 
 
 @dataclass(frozen=True)
@@ -204,6 +378,74 @@ def _hash_text(value: str) -> str:
     return hashlib.sha256(value.encode("utf-8")).hexdigest()
 
 
+def _publication_evidence_contract_body() -> dict[str, Any]:
+    return {
+        "schema": PUBLICATION_EVIDENCE_CAPABILITIES_SCHEMA,
+        "release_evidence_schema": PUBLICATION_EVIDENCE_SCHEMA,
+        "required_fields": list(PUBLICATION_EVIDENCE_FIELDS),
+        "bindings": {
+            "sha256_fields": [
+                "release_evidence_contract_sha256", "target_sha256",
+                "result_sha256", "approval_sha256", "quality_receipt_sha256",
+                "commercial_review_routing_contract_sha256",
+                "commercial_review_resolution_contract_sha256",
+            ],
+            "lineage_fields": ["evidence_request_id", "evidence_revision"],
+            "target_identity_fields": [
+                "job_id", "target_locale", "target_sha256", "approval_id",
+            ],
+            "quality_profile": "exact-current-target-locale-quality-profile",
+            "signed_container": "blun.cms-localization-publication.v3",
+        },
+        "commercial_scope": {
+            "content_type": "commercial",
+            "required_non_null": [
+                "commercial_profile", "commercial_quality_profile",
+                "commercial_review", "commercial_review_routing_contract_sha256",
+                "commercial_review_resolution_contract_sha256",
+            ],
+            "review_evidence_contract_sha256": (
+                "exact-current-public-commercial-evidence-contract"
+            ),
+            "review_resolution_contract_sha256": (
+                "exact-current-public-commercial-resolution-contract"
+            ),
+            "quality_profile": (
+                "exact-current-target-locale-commercial-quality-profile"
+            ),
+            "resolution": "required-only-when-review-required",
+            "non_commercial_fields": "all-null",
+        },
+        "content_policy": {
+            "source_text": False,
+            "target_text": False,
+            "raw_receipt": False,
+            "reviewer_identity": False,
+            "reviewer_prose": False,
+            "commercial_review_routing": False,
+            "project_prices": False,
+            "project_brands": False,
+            "authentication_material": False,
+        },
+        "tamper_policy": "reject-complete-publication-before-host-commit",
+    }
+
+
+def publication_evidence_contract() -> dict[str, Any]:
+    """Return the exact content-free contract advertised to CMS adapters."""
+    body = _publication_evidence_contract_body()
+    return {**body, "sha256": _hash_text(_canonical_json(body))}
+
+
+def validate_publication_evidence_contract(value: Any) -> dict[str, Any]:
+    """Reject a partial, reordered, altered, or merely rehashed contract."""
+    body = _publication_evidence_contract_body()
+    expected = {**body, "sha256": _hash_text(_canonical_json(body))}
+    if value != expected:
+        raise LocalizationReleaseBlocked("publication.evidence_contract.invalid")
+    return json.loads(_canonical_json(expected))
+
+
 def _text(value: Any, code: str, *, limit: int = 256) -> str:
     if not isinstance(value, str) or not value or value != value.strip():
         raise LocalizationReleaseBlocked(code)
@@ -242,12 +484,37 @@ def _independent_model_review(value: Any, primary_provider: dict[str, Any]) -> t
     return normalized, _receipt(value.get("receipt"), "independent_model_review.receipt.required")
 
 
+def _commercial_resolution_contract_sha256(
+    job: dict[str, Any],
+    result: dict[str, Any],
+) -> str | None:
+    commercial_profile = job.get("commercial_profile")
+    commercial_review = result["commercial_review"]
+    if commercial_profile is None or commercial_review["status"] != "review_required":
+        return None
+    try:
+        expected = _WORKER._COMMERCIAL.public_review_resolution_contract(
+            commercial_profile,
+        )["sha256"]
+    except (KeyError, TypeError, ValueError):
+        raise LocalizationReleaseBlocked("approval.binding_mismatch") from None
+    if (
+        job.get("commercial_review_resolution_contract_sha256") != expected
+        or result.get("commercial_review_resolution_contract_sha256")
+        != expected
+    ):
+        raise LocalizationReleaseBlocked("approval.binding_mismatch")
+    return expected
+
+
 def _receipt_binding(
     job_id: str,
     job: dict[str, Any],
     result: dict[str, Any],
     result_sha256: str,
     *,
+    evidence_request_id: str,
+    evidence_revision: str,
     review_kind: str,
     review_provider: dict[str, str] | None = None,
 ) -> dict[str, Any]:
@@ -257,9 +524,23 @@ def _receipt_binding(
         raise LocalizationReleaseBlocked("review.binding.invalid")
     if (review_kind == "independent_model") != (review_provider is not None):
         raise LocalizationReleaseBlocked("review.binding.invalid")
+    if (
+        not isinstance(evidence_request_id, str)
+        or EVIDENCE_REQUEST_ID.fullmatch(evidence_request_id) is None
+        or not isinstance(evidence_revision, str)
+        or TOKEN.fullmatch(evidence_revision) is None
+    ):
+        raise LocalizationReleaseBlocked("review.evidence_context.invalid")
+    commercial_profile = job.get("commercial_profile")
+    commercial_review = result["commercial_review"]
+    resolution_contract_sha256 = _commercial_resolution_contract_sha256(
+        job, result,
+    )
     binding = {
         "schema": RECEIPT_BINDING_SCHEMA,
         "review_kind": review_kind,
+        "evidence_request_id": evidence_request_id,
+        "evidence_revision": evidence_revision,
         "job_id": job_id,
         "result_sha256": result_sha256,
         "source_text": job["source"]["text"],
@@ -276,8 +557,15 @@ def _receipt_binding(
         "software_version": result["software_version"],
         "review_confidence": result["review_confidence"],
         "quality_profile": result["quality_profile"],
-        "commercial_profile": job.get("commercial_profile"),
-        "commercial_review": result["commercial_review"],
+        "commercial_profile": commercial_profile,
+        "commercial_review": commercial_review,
+        "commercial_review_routing": result["commercial_review_routing"],
+        "commercial_review_routing_contract_sha256": result[
+            "commercial_review_routing_contract_sha256"
+        ],
+        "commercial_review_resolution_contract_sha256": (
+            resolution_contract_sha256
+        ),
         "human_review_required": result["human_review_required"],
         "independent_review_required": result["independent_review_required"],
     }
@@ -351,7 +639,10 @@ def _validate_result(job: dict[str, Any], result: Any) -> dict[str, Any]:
         "source_locale", "target_locale", "content_type", "glossary_version",
         "policy_version", "provider", "software_version", "candidate",
         "quality_passes", "integrity", "review_confidence",
-        "quality_profile", "commercial_review", "human_review_required",
+        "quality_profile", "commercial_review", "commercial_review_routing",
+        "commercial_review_routing_contract_sha256",
+        "commercial_review_resolution_contract_sha256",
+        "human_review_required",
         "independent_review_required", "release_required",
     }
     if set(result) != expected:
@@ -379,6 +670,12 @@ def _validate_result(job: dict[str, Any], result: Any) -> dict[str, Any]:
         "version": job["target"]["quality_profile_version"],
         "sha256": job["target"]["quality_profile_sha256"],
     }
+    if job["content_type"] == "commercial":
+        expected_quality_profile["commercial"] = {
+            "profile": job["commercial_profile"],
+            "version": job["commercial_quality_profile"]["version"],
+            "sha256": job["commercial_quality_profile"]["sha256"],
+        }
     if result.get("quality_profile") != expected_quality_profile:
         raise LocalizationReleaseBlocked("result.quality_profile.invalid")
     if result.get("schema") != _WORKER.RESULT_SCHEMA or result.get("worker_schema") != _WORKER.WORKER_SCHEMA:
@@ -420,16 +717,48 @@ def _validate_result(job: dict[str, Any], result: Any) -> dict[str, Any]:
     ):
         raise LocalizationReleaseBlocked("result.independent_review.invalid")
     commercial_review = result.get("commercial_review")
+    commercial_review_routing = result.get("commercial_review_routing")
+    commercial_routing_contract_sha256 = result.get(
+        "commercial_review_routing_contract_sha256"
+    )
+    commercial_resolution_contract_sha256 = result.get(
+        "commercial_review_resolution_contract_sha256"
+    )
     if job["content_type"] == "commercial":
+        expected_routing_contract_sha256 = job[
+            "commercial_review_routing_contract_sha256"
+        ]
+        if commercial_routing_contract_sha256 != expected_routing_contract_sha256:
+            raise LocalizationReleaseBlocked("result.commercial_review.invalid")
+        if commercial_resolution_contract_sha256 != job[
+            "commercial_review_resolution_contract_sha256"
+        ]:
+            raise LocalizationReleaseBlocked("result.commercial_review.invalid")
         try:
-            _WORKER._COMMERCIAL.validate_summary(
+            commercial_review = _WORKER._COMMERCIAL.validate_summary(
                 commercial_review,
                 job["commercial_profile"],
                 review_required=independent_review_required,
             )
+            if commercial_review["status"] == "review_required":
+                _WORKER._COMMERCIAL.validate_review_routing_context(
+                    commercial_review_routing,
+                    job["source"]["text"],
+                    candidate,
+                    commercial_review,
+                    job["commercial_profile"],
+                )
+            elif commercial_review_routing is not None:
+                raise _WORKER._COMMERCIAL.CommercialReviewBlocked(
+                    "review.commercial.routing_invalid",
+                )
         except _WORKER._COMMERCIAL.CommercialReviewBlocked:
             raise LocalizationReleaseBlocked("result.commercial_review.invalid") from None
-    elif commercial_review is not None:
+    elif any(value is not None for value in (
+        commercial_review, commercial_review_routing,
+        commercial_routing_contract_sha256,
+        commercial_resolution_contract_sha256,
+    )):
         raise LocalizationReleaseBlocked("result.commercial_review.invalid")
     return result
 
@@ -491,6 +820,8 @@ class LocalizationReleaseStore:
         quality_verifier: QualityReceiptVerifier,
         authority: ApprovalAuthority,
         *,
+        evidence_request_id: str,
+        evidence_revision: str,
         now: float | int,
         ttl_seconds: float | int = 2_592_000,
         human_review_receipt: str | None = None,
@@ -508,6 +839,13 @@ class LocalizationReleaseStore:
         result_json = _canonical_json(result)
         result_hash = _hash_text(result_json)
         quality_receipt = _receipt(quality_receipt, "quality.receipt.invalid")
+        if (
+            not isinstance(evidence_request_id, str)
+            or EVIDENCE_REQUEST_ID.fullmatch(evidence_request_id) is None
+            or not isinstance(evidence_revision, str)
+            or TOKEN.fullmatch(evidence_revision) is None
+        ):
+            raise LocalizationReleaseBlocked("review.evidence_context.invalid")
         verifier = getattr(quality_verifier, "verify", None)
         if not callable(verifier):
             raise LocalizationReleaseBlocked("quality.verifier.invalid")
@@ -518,6 +856,8 @@ class LocalizationReleaseStore:
                     job,
                     result,
                     result_hash,
+                    evidence_request_id=evidence_request_id,
+                    evidence_revision=evidence_revision,
                     review_kind="quality",
                 ),
                 receipt=quality_receipt,
@@ -544,6 +884,8 @@ class LocalizationReleaseStore:
                         job,
                         result,
                         result_hash,
+                        evidence_request_id=evidence_request_id,
+                        evidence_revision=evidence_revision,
                         review_kind="qualified_human",
                     ),
                     receipt=human_review_receipt,
@@ -571,6 +913,8 @@ class LocalizationReleaseStore:
                             job,
                             result,
                             result_hash,
+                            evidence_request_id=evidence_request_id,
+                            evidence_revision=evidence_revision,
                             review_kind="independent_model",
                             review_provider=provider,
                         ),
@@ -598,6 +942,8 @@ class LocalizationReleaseStore:
                             job,
                             result,
                             result_hash,
+                            evidence_request_id=evidence_request_id,
+                            evidence_revision=evidence_revision,
                             review_kind="qualified_human",
                         ),
                         receipt=human_review_receipt,
@@ -616,6 +962,11 @@ class LocalizationReleaseStore:
 
         immutable = {
             "schema": APPROVAL_SCHEMA,
+            "release_evidence_contract_sha256": (
+                publication_evidence_contract()["sha256"]
+            ),
+            "evidence_request_id": evidence_request_id,
+            "evidence_revision": evidence_revision,
             "job_id": job_id,
             "source_sha256": result["source_sha256"],
             "target_sha256": result["target_sha256"],
@@ -629,10 +980,16 @@ class LocalizationReleaseStore:
             "worker_schema": result["worker_schema"],
             "review_confidence": result["review_confidence"],
             "quality_profile": result["quality_profile"],
+            "commercial_review_routing_contract_sha256": result[
+                "commercial_review_routing_contract_sha256"
+            ],
             "result_sha256": result_hash,
             "quality_receipt_sha256": _hash_text(quality_receipt),
             "human_review_receipt_sha256": human_hash,
             "independent_model_review": independent_binding,
+            "commercial_review_resolution_contract_sha256": (
+                _commercial_resolution_contract_sha256(job, result)
+            ),
         }
         approval_id = "blun-l10n-approval-" + _hash_text(_canonical_json(immutable))
         payload = {
@@ -715,19 +1072,28 @@ class LocalizationReleaseStore:
             raise LocalizationReleaseBlocked("translation_memory.json.invalid") from None
         result = _validate_result(job, result)
         expected_keys = {
-            "schema", "job_id", "source_sha256", "target_sha256", "source_locale",
+            "schema", "release_evidence_contract_sha256",
+            "evidence_request_id", "evidence_revision", "job_id",
+            "source_sha256", "target_sha256", "source_locale",
             "target_locale", "content_type", "glossary_version", "policy_version",
             "provider", "software_version", "worker_schema", "result_sha256",
             "review_confidence",
             "quality_profile",
+            "commercial_review_routing_contract_sha256",
             "quality_receipt_sha256", "human_review_receipt_sha256",
             "independent_model_review", "approval_id",
+            "commercial_review_resolution_contract_sha256",
             "approved_at", "expires_at",
         }
         if set(payload) != expected_keys:
             raise LocalizationReleaseBlocked("approval.binding_mismatch")
         binding = {
             "schema": APPROVAL_SCHEMA,
+            "release_evidence_contract_sha256": (
+                publication_evidence_contract()["sha256"]
+            ),
+            "evidence_request_id": payload.get("evidence_request_id"),
+            "evidence_revision": payload.get("evidence_revision"),
             "job_id": row["job_id"],
             "source_sha256": result["source_sha256"],
             "target_sha256": result["target_sha256"],
@@ -741,12 +1107,26 @@ class LocalizationReleaseStore:
             "worker_schema": result["worker_schema"],
             "review_confidence": result["review_confidence"],
             "quality_profile": result["quality_profile"],
+            "commercial_review_routing_contract_sha256": result[
+                "commercial_review_routing_contract_sha256"
+            ],
             "result_sha256": row["result_sha256"],
+            "commercial_review_resolution_contract_sha256": (
+                _commercial_resolution_contract_sha256(job, result)
+            ),
             "approved_at": row["approved_at"],
             "expires_at": row["expires_at"],
         }
         if any(payload.get(name) != value for name, value in binding.items()):
             raise LocalizationReleaseBlocked("approval.binding_mismatch")
+        if (
+            EVIDENCE_REQUEST_ID.fullmatch(
+                str(payload.get("evidence_request_id"))
+            ) is None
+            or not isinstance(payload.get("evidence_revision"), str)
+            or TOKEN.fullmatch(payload["evidence_revision"]) is None
+        ):
+            raise LocalizationReleaseBlocked("approval.binding_mismatch")
         if payload.get("approval_id") != row["approval_id"]:
             raise LocalizationReleaseBlocked("approval.binding_mismatch")
         if HEX64.fullmatch(str(payload.get("quality_receipt_sha256"))) is None:
@@ -811,6 +1191,9 @@ class LocalizationReleaseStore:
             candidate=result["candidate"],
             release_evidence=validate_publication_evidence({
                 "schema": PUBLICATION_EVIDENCE_SCHEMA,
+                "release_evidence_contract_sha256": payload[
+                    "release_evidence_contract_sha256"
+                ],
                 "job_id": row["job_id"],
                 "target_locale": row["target_locale"],
                 "target_sha256": row["target_sha256"],
@@ -819,10 +1202,33 @@ class LocalizationReleaseStore:
                 "result_sha256": row["result_sha256"],
                 "approval_sha256": row["approval_sha256"],
                 "quality_receipt_sha256": payload["quality_receipt_sha256"],
+                "evidence_request_id": payload["evidence_request_id"],
+                "evidence_revision": payload["evidence_revision"],
+                "quality_profile": {
+                    "locale": result["quality_profile"]["locale"],
+                    "version": result["quality_profile"]["version"],
+                    "sha256": result["quality_profile"]["sha256"],
+                },
                 "commercial_profile": job.get("commercial_profile"),
+                "commercial_quality_profile": (
+                    json.loads(_canonical_json(
+                        result["quality_profile"].get("commercial")
+                    ))
+                    if result["content_type"] == "commercial"
+                    else None
+                ),
                 "commercial_review": json.loads(
                     _canonical_json(result["commercial_review"])
                 ),
+                "commercial_review_routing_contract_sha256": result[
+                    "commercial_review_routing_contract_sha256"
+                ],
+                "commercial_review_resolution_contract_sha256": result[
+                    "commercial_review_resolution_contract_sha256"
+                ],
+                "commercial_review_resolution": _commercial_review_resolution(
+                    result, payload,
+                ),
             }),
             approved_at=float(row["approved_at"]),
             expires_at=float(row["expires_at"]),