blun-king-cli 9.1.597 → 9.1.600

package/standard-skills/translate-native/docs/WEBSITE_LOCALIZATION_EVIDENCE_HTTP.md

@@ -29,11 +29,13 @@ Neither credentials nor remote response prose appears in adapter errors.
 ## Request
 
 The adapter accepts only the coordinator's exact immutable
-`blun.localization-quality-evidence-request.v5` object. It validates the
-complete field set, request ID, SHA-256 values, locale profile, model identity,
-confidence decisions, optional commercial profile and its exact content-free
-targeted-review summary, UTF-8 size, Unicode NFC, and the source and target text
-hashes before authentication or transport.
+`blun.localization-quality-evidence-request.v14` object. It validates the
+complete field set, derives the request ID, and checks SHA-256 values, locale
+profile, model identity,
+confidence decisions, and, for commercial content, the exact locale-specific
+commercial quality-profile binding plus its content-free targeted-review
+summary, UTF-8 size, Unicode NFC, and the source and target text hashes before
+authentication or transport.
 
 It sends one canonical UTF-8 JSON document:
 
@@ -43,7 +45,7 @@ It sends one canonical UTF-8 JSON document:
   "request_id": "blun-l10n-evidence-<64 lowercase hexadecimal characters>",
   "request_sha256": "<SHA-256 of the canonical inner request>",
   "request": {
-    "schema": "blun.localization-quality-evidence-request.v5",
+    "schema": "blun.localization-quality-evidence-request.v14",
     "request_id": "<same request ID>",
     "source_locale": "en-IE",
     "target_locale": "fi-FI",
@@ -53,6 +55,11 @@ It sends one canonical UTF-8 JSON document:
     "source_sha256": "<source-text hash>",
     "target_sha256": "<target-text hash>",
     "content_type": "headline",
+    "commercial_review_routing": null,
+    "commercial_review_routing_contract_sha256": null,
+    "commercial_review_routing_contract": null,
+    "commercial_review_resolution_contract_sha256": null,
+    "commercial_review_resolution_contract": null,
     "quality_profile": {
       "locale": "fi-FI",
       "version": "<locale profile version>",
@@ -63,13 +70,57 @@ It sends one canonical UTF-8 JSON document:
 ```
 
 The abbreviated example omits other required inner fields for readability.
-Production requests always contain exactly the full v5 field set. Commercial
-requests include `commercial_profile` and the matching `commercial_review`
-summary; non-commercial requests require both fields to be `null`. Source and
+Production requests always contain exactly the full v14 field set. Commercial
+requests include `commercial_profile`, the matching `commercial_review`
+summary, and `quality_profile.commercial` with the same profile identifier plus
+its exact locale-specific version and SHA-256 digest. The summary binds the
+exact advertised commercial review-evidence-contract SHA-256, so a prior
+structurally valid report cannot be reinterpreted under a changed contract. An unresolved commercial
+summary additionally carries the canonical advertised resolution-contract
+SHA-256 and the complete content-free resolution contract. Both fields are
+part of the deterministic request ID, so a reviewer can resolve the targeted
+uncertainty without separate capability discovery. The coordinator and HTTP
+adapter independently reconstruct the current contract and reject a missing,
+stale, substituted, or merely self-rehashed object before provider access.
+Verified commercial results and non-commercial requests require both fields
+to be `null`.
+Every commercial request also carries
+`commercial_review_routing_contract_sha256`, even when the commercial review
+is already verified and no private offer route is needed. This lets the
+evidence provider issue the receipt against the same exact public contract
+digest that the receipt verifier, signed approval, and CMS evidence later
+require. Non-commercial requests require this field to be `null`.
+An unresolved commercial request also carries a private
+`commercial_review_routing` object. It maps every zero-based opaque offer index
+to its ordered, non-overlapping source and target Unicode code-point spans and
+binds both complete text lengths. The object contains no configured offer ID,
+text, price, brand, or reviewer prose. It also carries the exact SHA-256 of the
+separately advertised machine-readable routing contract. The sibling
+`commercial_review_routing_contract` field contains that complete content-free
+contract, so a remote reviewer does not depend on separate capability
+discovery. The adapter reconstructs the canonical object and validates the
+route against the exact source, target, summary, and profile before
+authentication or transport. Route, digest, and full contract are part of the
+deterministic request ID. Verified commercial results and non-commercial
+requests require both route and routing contract to be `null`.
+Non-commercial requests require every commercial field to be `null` and forbid
+the nested commercial quality profile.
+Source and
 target text are intentionally present because this external step verifies the
 existing source-blind native review and the separate source-aware fidelity
 review. The service must preserve their confidentiality.
 
+The suffix of `request_id` is the SHA-256 of canonical UTF-8 JSON containing
+exactly `schema`, `evidence_revision`, `event_id`, `plan_id`, `job_id`,
+`result_sha256`, both text hashes, both locales, `content_type`, glossary and
+policy versions, provider/model identity, software version, both confidence
+decisions, the complete locale quality profile, commercial profile and review,
+the routing-contract digest, the conditional commercial review-routing object,
+its complete routing contract, the resolution-contract hash, and both escalation
+flags. The full texts and `request_id` itself are excluded from that identity;
+their exact bytes are already bound by `source_sha256` and `target_sha256`.
+The durable store and HTTP adapter independently recompute this same identity.
+
 The adapter adds:
 
 ```text
@@ -109,11 +160,15 @@ numbers, a UTF-8 byte-order mark, wrong bindings, ambiguous content types,
 incorrect lengths, and oversized bodies. The release coordinator then applies
 its existing independent receipt checks. Each opaque receipt must verify
 against the complete canonical
-`blun.localization-quality-receipt-binding.v2` object supplied by the release
+`blun.localization-quality-receipt-binding.v9` object supplied by the release
 coordinator, including the review purpose, job and result hashes, both texts
 and locales, content type, glossary and policy versions, provider/model and
 software identities, locale quality and commercial profiles, the exact
-commercial review scope, confidence, and escalation requirements. Reuse across
+commercial review scope, canonical resolution-contract SHA-256, confidence,
+the exact public offer-routing-contract SHA-256, the private offer-routing
+context, escalation requirements, and the exact
+evidence request ID and revision from
+this response. Reuse across
 a changed field or between quality,
 qualified-human, and independent-model review purposes must fail closed.
 Legal content still requires a

package/standard-skills/translate-native/docs/WEBSITE_LOCALIZATION_HTTP_PROVIDER.md

@@ -80,7 +80,7 @@ The JSON envelope has exactly four fields:
   "request_id": "<deterministic phase request ID>",
   "request_sha256": "<SHA-256 of canonical request JSON>",
   "request": {
-    "schema": "blun.website-localization-worker.v4",
+    "schema": "blun.website-localization-worker.v9",
     "request_id": "<same deterministic phase request ID>",
     "phase": "transcreation",
     "provider_id": "customer-llm",
@@ -98,6 +98,24 @@ the `target_native` input intentionally excludes the source text and
 source-language glossary terms; reconstructing or fetching that source would
 invalidate the independent, source-blind review.
 
+For commercial content, only `source_fidelity` receives
+`commercial_review_evidence_contract`. This is the complete content-free,
+SHA-256-bound public contract for the required offer registry, Unicode spans,
+ten checks, exact per-offer verdict coverage, deterministic aggregate-status
+derivation, limits, and fail-closed trust boundary. The
+worker verifies it against the installed public commercial profile before the
+first provider call. Transcreation and source-blind native review do not receive
+this contract. The provider still returns the private evidence only under
+`response_schema.commercial_review`; the public contract itself contains no
+project price, brand, source, target, span, or reviewer prose.
+
+Commercial plan v4 and job v4 payloads also bind the exact public
+offer-routing-contract SHA-256. Worker v8 reconstructs that contract together
+with the review-evidence contract before any provider request, so queue health,
+lease validation, retries, and provider invocation reject obsolete routing
+semantics under the same deterministic job identity. Non-commercial jobs omit
+both commercial contract digests.
+
 `request_sha256` is the lowercase hexadecimal SHA-256 of `request` encoded as
 UTF-8 JSON with keys sorted, no insignificant whitespace, native Unicode
 characters unescaped, and non-finite numbers forbidden. The bundled adapter

package/standard-skills/translate-native/docs/WEBSITE_LOCALIZATION_RECEIPT_VERIFIER_HTTP.md

@@ -25,11 +25,18 @@ retry and its attempt limit.
 ## Request
 
 The adapter canonicalizes the complete
-`blun.localization-quality-receipt-binding.v2` object and validates its native
+`blun.localization-quality-receipt-binding.v9` object and validates its native
 Unicode text, hashes, locales, content type, glossary and policy versions,
 provider/model identities, software version, two-pass confidence, locale
-quality profile, optional commercial profile and exact targeted-review summary,
-escalation requirements, and review purpose. It then sends HTTP POST with JSON content type and these
+quality profile, exact locale-specific commercial profile when applicable,
+matching targeted-review summary and its exact review-evidence-contract
+SHA-256, the exact current offer-routing-contract SHA-256, the canonical
+resolution-contract SHA-256
+and the private, text-free mapping from opaque offer indexes to exact source
+and target Unicode code-point spans for unresolved commercial review,
+escalation requirements, review purpose,
+canonical quality-evidence request ID, and evidence revision.
+It then sends HTTP POST with JSON content type and these
 protected headers:
 
 - `Idempotency-Key`;
@@ -44,15 +51,24 @@ The body is exactly:
   "request_id": "blun-l10n-receipt-<sha256>",
   "binding_sha256": "<canonical binding hash>",
   "receipt_sha256": "<opaque receipt hash>",
-  "binding": {"schema": "blun.localization-quality-receipt-binding.v2"},
+  "binding": {"schema": "blun.localization-quality-receipt-binding.v9"},
   "receipt": "<opaque receipt>"
 }
 ```
 
 The deterministic request ID is derived from both hashes. Identical retries
 therefore address the same verification operation, while any changed receipt
-or binding dimension receives a different identity. The remote service must
+or binding dimension—including the evidence request ID or revision—receives a
+different identity. The remote service must
 treat an idempotency-key collision with different bytes as a terminal error.
+The adapter recomputes the commercial resolution-contract digest from the
+installed profile before authentication or transport. Verified commercial and
+non-commercial bindings require both that digest and the routing object to be
+`null`. For unresolved review, it validates span order, bounds, text lengths,
+offer count, and exact opaque index order before any credential callback or
+network access. It also reconstructs and requires the exact digest of the
+separately advertised machine-readable routing contract. The routing object
+never contains configured offer IDs, text, prices, brands, or reviewer prose.
 
 ## Response
 
@@ -83,4 +99,6 @@ statuses, binding mismatches, and explicit negative verdicts are terminal.
 
 The same adapter can be configured separately for quality, qualified-human,
 and independent-model receipts. Purpose is part of the signed binding, so a
-receipt accepted for one route cannot satisfy another route.
+receipt accepted for one route cannot satisfy another route. Evidence context
+is also part of the binding, so a receipt cannot be relabelled beneath a newer
+provider response envelope.

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

@@ -27,11 +27,32 @@ _SPEC.loader.exec_module(_IMPL)
 
 hashlib = _IMPL.hashlib
 PUBLIC_PROFILE_SCHEMA = _IMPL.PUBLIC_PROFILE_SCHEMA
+REVIEW_EVIDENCE_CAPABILITIES_SCHEMA = (
+    _IMPL.REVIEW_EVIDENCE_CAPABILITIES_SCHEMA
+)
 REVIEW_SUMMARY_CAPABILITIES_SCHEMA = _IMPL.REVIEW_SUMMARY_CAPABILITIES_SCHEMA
 REVIEW_SUMMARY_SCHEMA = _IMPL.REVIEW_SUMMARY_SCHEMA
+REVIEW_ROUTING_CAPABILITIES_SCHEMA = (
+    _IMPL.REVIEW_ROUTING_CAPABILITIES_SCHEMA
+)
+REVIEW_ROUTING_SCHEMA = _IMPL.REVIEW_ROUTING_SCHEMA
+EVIDENCE_BINDING_SCHEMA = _IMPL.EVIDENCE_BINDING_SCHEMA
+REVIEW_RESOLUTION_CAPABILITIES_SCHEMA = (
+    _IMPL.REVIEW_RESOLUTION_CAPABILITIES_SCHEMA
+)
+REVIEW_RESOLUTION_SCHEMA = _IMPL.REVIEW_RESOLUTION_SCHEMA
+COMMERCIAL_LOCALE_PROFILE_SCHEMA = _IMPL.COMMERCIAL_LOCALE_PROFILE_SCHEMA
+COMMERCIAL_RENDERING_REFERENCE_SCHEMA = (
+    _IMPL.COMMERCIAL_RENDERING_REFERENCE_SCHEMA
+)
 DIMENSIONS = _IMPL.DIMENSIONS
 _canonical_json = _IMPL._canonical_json
+evidence_sha256 = _IMPL.evidence_sha256
+public_review_evidence_contract = _IMPL.public_review_evidence_contract
 public_review_summary_contract = _IMPL.public_review_summary_contract
+public_review_routing_contract = _IMPL.public_review_routing_contract
+public_review_resolution_contract = _IMPL.public_review_resolution_contract
+validate_review_resolution = _IMPL.validate_review_resolution
 public_profile = _IMPL.public_profile
 CREATION_GUIDANCE = _IMPL.CREATION_GUIDANCE
 NATIVE_GUIDANCE = _IMPL.NATIVE_GUIDANCE
@@ -40,3 +61,5 @@ CommercialReviewBlocked = _IMPL.CommercialReviewBlocked
 review_contract = _IMPL.review_contract
 validate_review = _IMPL.validate_review
 validate_summary = _IMPL.validate_summary
+validate_review_routing_context = _IMPL.validate_review_routing_context
+review_routing_context = _IMPL.review_routing_context

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

@@ -21,8 +21,8 @@ from pathlib import Path
 from typing import Any, Iterable, Mapping, Sequence
 
 
-SCHEMA = "blun.website-localization-plan.v2"
-JOB_SCHEMA = "blun.website-localization-job.v2"
+SCHEMA = "blun.website-localization-plan.v5"
+JOB_SCHEMA = "blun.website-localization-job.v5"
 EU_LANGUAGE_SOURCE = (
     "https://european-union.europa.eu/principles-countries-history/languages_en"
 )
@@ -42,7 +42,7 @@ CONTENT_TYPES = frozenset({
     "commercial",
 })
 QUALITY_PASSES = ("target_native", "source_fidelity")
-COMMERCIAL_PROFILE = "translate-native.commercial.v2"
+COMMERCIAL_PROFILE = "translate-native.commercial.v13"
 
 
 class LocalizationPlanBlocked(ValueError):
@@ -78,6 +78,25 @@ def _load_quality_profiles():
 
 
 _QUALITY_PROFILES = _load_quality_profiles()
+COMMERCIAL_RENDERING_REGISTRY_SCHEMA = (
+    _QUALITY_PROFILES.COMMERCIAL_RENDERING_REGISTRY_SCHEMA
+)
+
+
+def _load_commercial_profile():
+    path = Path(__file__).with_name("commercial_localization_profile.py")
+    spec = importlib.util.spec_from_file_location(
+        "blun_website_planner_commercial_profile", path,
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError("cannot load commercial localization profile")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_COMMERCIAL = _load_commercial_profile()
 
 
 def _locale(locale: str, eu_code: str, language: str, native_name: str, script: str) -> LocaleProfile:
@@ -123,6 +142,126 @@ def quality_profile_for(locale: str) -> dict[str, Any]:
     return _QUALITY_PROFILES.quality_profile_for(locale)
 
 
+def commercial_quality_profile_for(locale: str) -> dict[str, Any]:
+    return _QUALITY_PROFILES.commercial_quality_profile_for(
+        locale,
+        COMMERCIAL_PROFILE,
+    )
+
+
+def commercial_rendering_registry() -> dict[str, Any]:
+    return _QUALITY_PROFILES.commercial_rendering_registry(COMMERCIAL_PROFILE)
+
+
+def commercial_review_evidence_contract_sha256() -> str:
+    """Return the exact current evidence-contract generation or fail closed."""
+    try:
+        contract = _COMMERCIAL.public_review_evidence_contract(
+            COMMERCIAL_PROFILE,
+        )
+        public_contract = _COMMERCIAL.public_profile(COMMERCIAL_PROFILE)[
+            "review_evidence_contract"
+        ]
+        if not isinstance(contract, dict) or not isinstance(
+            public_contract, dict
+        ):
+            raise TypeError
+        unsigned = dict(contract)
+        digest = unsigned.pop("sha256")
+        computed_digest = _digest(unsigned)
+    except (KeyError, TypeError, ValueError) as error:
+        raise LocalizationPlanBlocked(
+            "commercial review-evidence contract is invalid"
+        ) from error
+    if (
+        contract != public_contract
+        or contract.get("schema")
+        != _COMMERCIAL.REVIEW_EVIDENCE_CAPABILITIES_SCHEMA
+        or contract.get("result_schema") != COMMERCIAL_PROFILE
+        or contract.get("profile") != COMMERCIAL_PROFILE
+        or not isinstance(digest, str)
+        or re.fullmatch(r"[0-9a-f]{64}", digest) is None
+        or digest != computed_digest
+    ):
+        raise LocalizationPlanBlocked(
+            "commercial review-evidence contract is invalid"
+        )
+    return digest
+
+
+def commercial_review_routing_contract_sha256() -> str:
+    """Return the exact current private-routing contract or fail closed."""
+    try:
+        contract = _COMMERCIAL.public_review_routing_contract(
+            COMMERCIAL_PROFILE,
+        )
+        public_contract = _COMMERCIAL.public_profile(COMMERCIAL_PROFILE)[
+            "review_routing_contract"
+        ]
+        if not isinstance(contract, dict) or not isinstance(
+            public_contract, dict
+        ):
+            raise TypeError
+        unsigned = dict(contract)
+        digest = unsigned.pop("sha256")
+        computed_digest = _digest(unsigned)
+    except (KeyError, TypeError, ValueError) as error:
+        raise LocalizationPlanBlocked(
+            "commercial review-routing contract is invalid"
+        ) from error
+    if (
+        contract != public_contract
+        or contract.get("schema")
+        != _COMMERCIAL.REVIEW_ROUTING_CAPABILITIES_SCHEMA
+        or contract.get("result_schema") != _COMMERCIAL.REVIEW_ROUTING_SCHEMA
+        or contract.get("profile") != COMMERCIAL_PROFILE
+        or not isinstance(digest, str)
+        or re.fullmatch(r"[0-9a-f]{64}", digest) is None
+        or digest != computed_digest
+    ):
+        raise LocalizationPlanBlocked(
+            "commercial review-routing contract is invalid"
+        )
+    return digest
+
+
+def commercial_review_resolution_contract_sha256() -> str:
+    """Return the exact current review-resolution contract or fail closed."""
+    try:
+        contract = _COMMERCIAL.public_review_resolution_contract(
+            COMMERCIAL_PROFILE,
+        )
+        public_contract = _COMMERCIAL.public_profile(COMMERCIAL_PROFILE)[
+            "review_resolution_contract"
+        ]
+        if not isinstance(contract, dict) or not isinstance(
+            public_contract, dict
+        ):
+            raise TypeError
+        unsigned = dict(contract)
+        digest = unsigned.pop("sha256")
+        computed_digest = _digest(unsigned)
+    except (KeyError, TypeError, ValueError) as error:
+        raise LocalizationPlanBlocked(
+            "commercial review-resolution contract is invalid"
+        ) from error
+    if (
+        contract != public_contract
+        or contract.get("schema")
+        != _COMMERCIAL.REVIEW_RESOLUTION_CAPABILITIES_SCHEMA
+        or contract.get("result_schema")
+        != _COMMERCIAL.REVIEW_RESOLUTION_SCHEMA
+        or contract.get("profile") != COMMERCIAL_PROFILE
+        or not isinstance(digest, str)
+        or re.fullmatch(r"[0-9a-f]{64}", digest) is None
+        or digest != computed_digest
+    ):
+        raise LocalizationPlanBlocked(
+            "commercial review-resolution contract is invalid"
+        )
+    return digest
+
+
 @dataclass(frozen=True)
 class LocalizationJob:
     job_id: str
@@ -139,9 +278,43 @@ class LocalizationJob:
     model_id: str
     model_version: str
     software_version: str
+    commercial_review_evidence_contract_sha256: str | None = None
+    commercial_review_routing_contract_sha256: str | None = None
+    commercial_review_resolution_contract_sha256: str | None = None
 
     def as_payload(self) -> dict[str, Any]:
         """Return the provider-neutral queue payload for one target locale."""
+        commercial = (
+            commercial_quality_profile_for(self.target.locale)
+            if self.content_type == "commercial"
+            else None
+        )
+        commercial_evidence_sha256 = (
+            commercial_review_evidence_contract_sha256()
+            if commercial is not None
+            else None
+        )
+        commercial_routing_sha256 = (
+            commercial_review_routing_contract_sha256()
+            if commercial is not None
+            else None
+        )
+        commercial_resolution_sha256 = (
+            commercial_review_resolution_contract_sha256()
+            if commercial is not None
+            else None
+        )
+        if (
+            self.commercial_review_evidence_contract_sha256
+            != commercial_evidence_sha256
+            or self.commercial_review_routing_contract_sha256
+            != commercial_routing_sha256
+            or self.commercial_review_resolution_contract_sha256
+            != commercial_resolution_sha256
+        ):
+            raise LocalizationPlanBlocked(
+                "commercial review contract binding is stale"
+            )
         return {
             "schema": JOB_SCHEMA,
             "job_id": self.job_id,
@@ -165,7 +338,23 @@ class LocalizationJob:
             "software_version": self.software_version,
             "quality_passes": list(QUALITY_PASSES),
             "release_required": True,
-            **({"commercial_profile": COMMERCIAL_PROFILE} if self.content_type == "commercial" else {}),
+            **(
+                {
+                    "commercial_profile": COMMERCIAL_PROFILE,
+                    "commercial_quality_profile": commercial,
+                    "commercial_review_evidence_contract_sha256": (
+                        commercial_evidence_sha256
+                    ),
+                    "commercial_review_routing_contract_sha256": (
+                        commercial_routing_sha256
+                    ),
+                    "commercial_review_resolution_contract_sha256": (
+                        commercial_resolution_sha256
+                    ),
+                }
+                if commercial is not None
+                else {}
+            ),
         }
 
 
@@ -319,11 +508,38 @@ def plan_website_localization(
         "software_version": software_version,
         "quality_passes": QUALITY_PASSES,
     }
+    commercial_evidence_sha256 = None
+    commercial_routing_sha256 = None
+    commercial_resolution_sha256 = None
     if content_type == "commercial":
         common["commercial_profile"] = COMMERCIAL_PROFILE
-    jobs = tuple(
-        LocalizationJob(
-            job_id="blun-l10n-" + _digest({**common, "target": asdict(profile)}),
+        commercial_evidence_sha256 = (
+            commercial_review_evidence_contract_sha256()
+        )
+        common["commercial_review_evidence_contract_sha256"] = (
+            commercial_evidence_sha256
+        )
+        commercial_routing_sha256 = (
+            commercial_review_routing_contract_sha256()
+        )
+        common["commercial_review_routing_contract_sha256"] = (
+            commercial_routing_sha256
+        )
+        commercial_resolution_sha256 = (
+            commercial_review_resolution_contract_sha256()
+        )
+        common["commercial_review_resolution_contract_sha256"] = (
+            commercial_resolution_sha256
+        )
+    jobs_list = []
+    for profile in profiles:
+        job_binding = {**common, "target": asdict(profile)}
+        if content_type == "commercial":
+            job_binding["commercial_quality_profile"] = (
+                commercial_quality_profile_for(profile.locale)
+            )
+        jobs_list.append(LocalizationJob(
+            job_id="blun-l10n-" + _digest(job_binding),
             source_id=source_id,
             source_revision=source_revision,
             source_text=source_text,
@@ -337,9 +553,17 @@ def plan_website_localization(
             model_id=model_id,
             model_version=model_version,
             software_version=software_version,
-        )
-        for profile in profiles
-    )
+            commercial_review_evidence_contract_sha256=(
+                commercial_evidence_sha256
+            ),
+            commercial_review_routing_contract_sha256=(
+                commercial_routing_sha256
+            ),
+            commercial_review_resolution_contract_sha256=(
+                commercial_resolution_sha256
+            ),
+        ))
+    jobs = tuple(jobs_list)
     plan_binding = {
         **common,
         "target_locales": [job.target.locale for job in jobs],

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

@@ -734,7 +734,10 @@ def _validate_worker_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 not isinstance(result, dict) or set(result) != expected_keys:
@@ -771,16 +774,49 @@ def _validate_worker_result(job: dict[str, Any], result: Any) -> dict[str, Any]:
         job["content_type"] != "legal" and "low" in review_confidence.values()
     )
     commercial_review = result["commercial_review"]
+    commercial_review_routing = result["commercial_review_routing"]
+    commercial_routing_contract_sha256 = result[
+        "commercial_review_routing_contract_sha256"
+    ]
+    commercial_resolution_contract_sha256 = result[
+        "commercial_review_resolution_contract_sha256"
+    ]
     if job["content_type"] == "commercial":
+        if (
+            commercial_routing_contract_sha256
+            != job["commercial_review_routing_contract_sha256"]
+            or commercial_resolution_contract_sha256
+            != job["commercial_review_resolution_contract_sha256"]
+        ):
+            raise BenchmarkBlocked(
+                "benchmark.candidate.commercial_review_invalid"
+            )
         try:
-            _WORKER._COMMERCIAL.validate_summary(
+            commercial_review = _WORKER._COMMERCIAL.validate_summary(
                 commercial_review,
                 job["commercial_profile"],
                 review_required=expected_independent_review,
             )
+            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 BenchmarkBlocked("benchmark.candidate.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 BenchmarkBlocked("benchmark.candidate.commercial_review_invalid")
     expected_quality_profile = {
         "locale": job["target"]["locale"],