blun-king-cli 9.1.587 → 9.1.588

package/standard-skills/translate-native/references/commercial-localization.md

@@ -0,0 +1,177 @@
+# Commercial localization — profile v2
+
+Use for pricing pages, offer cards, checkout copy, subscription CTAs, discounts,
+trials and associated conditions in **any language or script**. The skill is
+language-neutral; the website planner currently supplies 24 EU locale profiles.
+Technical coverage does not establish native fluency in those languages.
+
+## Keep the offer intact
+
+Before drafting, map each proposition to its product/tier and source segment.
+Include headings, neighboring cards, footnotes and linked condition labels.
+Preserve:
+
+- amount, currency identity, unit and the product receiving that price;
+- discount/saving, comparison basis, eligibility and reference period;
+- qualifiers such as “from”, “up to”, “only” and minimum quantities;
+- stated tax inclusion/exclusion and scope, without inferring local tax rules;
+- billing frequency and amount charged, distinct from an equivalent monthly
+  display price or minimum contract term;
+- trial cost/duration, introductory period, renewal terms and subsequent price;
+- cancellation deadline, notice, fees, refunds and exceptions;
+- remaining limits, tier counts, dates, eligibility and attached conditions.
+
+“Four tiers” counts pricing levels, not payment installments. “Save up to” does
+not promise every customer that saving. A yearly contract billed monthly is not
+a monthly cancellable subscription. Do not add missing terms to improve copy.
+
+## Preserve meaning, allow native presentation
+
+Allow locale-appropriate separators, spacing, currency position, native digits,
+number words, written percentages and inflected unit expressions. These must
+express the same value and commercial relationship. Do not perform currency
+conversion, round prices, or change tax treatment. An explicit request to keep
+an exact number/symbol spelling overrides formatting adaptation.
+
+Never interpret `1,234` without reliable locale and source context. “12 months”
+and “one year” can be equivalent, but calendar dates, commitment, charging and
+renewal conditions must still agree. A digit-count or number-multiset regex is
+neither proof of fidelity nor grounds to reject an otherwise equivalent form.
+
+Read protected names and slogans from the project brief/glossary. Protect an
+acrostic tagline verbatim when requested; do not translate its initials away.
+There is no public default list of brands, tier names, amounts or currencies.
+
+## Review and uncertainty
+
+First hide the source and judge idiomatic commercial language, CTA effect,
+register, rhythm, typography and comprehensibility as original native copy.
+Then compare the full source and target proposition by proposition. Check both
+omissions and added promises. Match each price and condition to its own offer;
+equal totals across two cards do not excuse swapped prices.
+
+Record a known mismatch as blocking. If a value, condition, coverage or native
+usage remains unresolved, request an independent model adapter or qualified
+native/domain reviewer. Do not mark uncertainty as a successful check or invent
+a translation to fill a gap. A grammatical target and model confidence alone
+are not publication evidence. Neither average scores nor unrelated successful
+checks override a blocking or major defect.
+
+## Skill-only evidence check
+
+The executable checker and its shared validator ship in this skill's `scripts/`
+directory. No `integrations/` directory, server, model credentials or network is
+needed for this local check. Run from the skill directory:
+
+```bash
+python3 scripts/check_commercial_review.py --contract
+python3 scripts/check_commercial_review.py --source source.txt --target target.txt --review review.json
+```
+
+The contract is a description, not a completed review. First perform the
+source-blind native review, then have the source-aware reviewer produce the
+`commercial_review` object; save that object alone as `review.json`. Do not
+manufacture positive evidence to satisfy the checker. Supply the full unchanged
+source and target, not extracted price fragments. Inputs must be UTF-8 without
+BOM, at most 2,000,000 bytes each. Character spans count Unicode code points, not
+UTF-8 bytes or JavaScript UTF-16 units. Line endings are preserved; do not
+normalize or edit the files after producing the evidence offsets.
+
+Exit 1 and `BLOCK` mean malformed, changed or unresolved evidence. Missing
+arguments exit 2. Exit 0 and `EVIDENCE_VALID` mean only that the evidence meets
+the structural contract, **not that prices are correct or the text is ready**.
+All machine results say `release_allowed: false`; no token is issued. Successful
+checks include hashes of the exact inputs for traceability, not an authenticated
+receipt. The independent quality assessment, structural/orthography guards and
+host-verified signed release remain necessary. Unknown language/domain facts
+must still go to an independent adapter or qualified reviewer.
+
+This helper neither starts nor locates a deployed checking service. The website
+worker uses this same validator through a compatibility module in `integrations/`.
+The ordinary MCP/response guard is not automatically wired to commercial review
+by copying the skill; the trusted host must use the commercial worker path and
+enforce its quality and publication gates. Do not claim coverage for a live
+BLUN agent without testing that actual path. When updating an installation with
+local guard patches, preserve and reconcile those patches; this helper does not
+require replacing `scripts/blun_language_guard.py`.
+
+## Website worker contract
+
+The trusted CMS/backend selects `content_type: "commercial"` for complete offer
+copy, including its CTA and conditions. Do not let a generating agent downgrade
+it to `marketing` or `ui` to avoid review. Keep genuinely legal terms on the
+existing `legal` path with required human review; this profile is not a legal
+approval. For mixed pages, supply complete contextual commercial units rather
+than isolated price fragments.
+
+The planner binds `translate-native.commercial.v2` into the job and plan IDs.
+The authenticated capabilities response publishes the same profile as a
+separately hashed, brand-neutral machine-readable contract. It lists all ten
+semantic dimensions, exact preservation rules, permitted locale-aware
+rendering, the evidence method and the fail-closed route for ambiguity. CMS
+integrations can therefore preflight the implemented offer contract without
+receiving project prices, product lists, protected terms or deployment secrets.
+Its separately hashed `review_summary_contract` also declares the exact five
+summary fields, both valid statuses, the only permitted ordered dimension
+names, the evidence-hash canonicalization and the explicit exclusion of source
+text, target text, spans, reviewer prose, project prices and project brands.
+Adapters therefore do not need to infer the targeted-review envelope from a
+schema name or prose. A changed, missing, reordered or unknown dimension makes
+the complete capability response unavailable.
+The worker uses the existing three ordered passes; the source-fidelity response
+additionally requires `commercial_review`. It contains all ten named dimensions,
+coverage and per-offer evidence. Each item declares `matched`, `source_only`, or
+`target_only` and supplies exact source/target character spans; the absent side
+of a one-sided item is `null`. Equivalent evidence must be matched. A specific
+changed or uncertain verdict needs a concrete item, while globally uncertain
+coverage may remain span-free rather than fabricate a location.
+Missing/malformed checks, impossible relation/span combinations and changed
+terms produce no result or approval. Uncertainty or an all-absent report preserves the candidate only as a
+low-confidence fidelity result. It remains unpublishable until the host verifies
+exactly one qualified native/domain review or an independent second-provider
+model receipt bound to the commercial profile and policy. The worker does not
+secretly call an alternative provider.
+
+The worker retains a content-free `commercial_review` summary in result schema
+v5. It contains only the profile, verdict, ordered unresolved dimension names
+and a hash of the complete commercial evidence. Prices, text spans,
+interpretations and reviewer prose do not survive in the summary. The same
+summary is bound into quality-evidence request schema v5 and receipt-binding
+schema v2, so an independent adapter receives the exact targeted scope and
+cannot replace it with a generic approval. Tampered, unknown, reordered or
+contradictory dimensions block before network access or signing.
+
+The validator checks evidence shape and offsets, **not semantic truth**. A model
+can misinterpret text or omit a fact while claiming completeness. The host's
+independent quality-receipt verifier must inspect the complete request/response
+and adequacy of evidence before signing; existing signature/readiness gates
+remain mandatory. No live provider or native-editor quality is established by
+scripted adapter tests. Profile changes require a new profile version, and
+project condition/glossary/prompt changes require new bound policy versions.
+
+The website benchmark suite v4 treats commercial localization as one of eight
+separately gated content-type lanes. Each locale needs all eight brand-neutral
+commercial cases and must pass the predeclared joint, target-native, and
+source-fidelity statistics inside that lane. Wins on headlines, UI, or other
+content cannot compensate for a weak pricing lane, just as commercial wins
+cannot hide another weak content type. These gates prove only the integrity of
+recorded blind evidence; they do not manufacture native review or establish
+superiority without real qualified reviewers and a lawful baseline.
+
+Its hashed manifest binds the same ten ordered dimensions as this profile to
+every commercial case. This includes dimensions absent from the source, because
+the target must also be checked for invented prices, discounts, terms, or
+conditions. The runner validates the exact list before either external pass and
+provides it only to source-fidelity review. Source-blind native review receives
+neither the source nor this semantic scope. Missing, additional, or reordered
+dimensions fail closed before a reviewer is called.
+
+The fidelity reviewer must return
+`translate-native.commercial-benchmark-review.v1`: one ordered item for every
+dimension and a decision for each anonymous variant. `equivalent` and
+`not_present` carry no defect reference. `major` and `blocking` point to the
+matching variant's zero-based defect entry, so a generic preference cannot hide
+which commercial check failed. `uncertain`, incomplete, reordered, additional,
+or contradictory acknowledgements fail closed. Only canonical response hashes,
+defect counts, and finding hashes survive in case evidence; reviewer prose does
+not.

package/standard-skills/translate-native/scripts/blun_language_guard.py

@@ -196,7 +196,13 @@ def validate_text(
     base_language = language.casefold().replace("_", "-").split("-", 1)[0]
     profile = LANGUAGE_CHARACTER_PROFILES.get(base_language)
     profile_prose = DIACRITICS.mask_technical_text(text)
-    if profile and len(profile_prose) >= 200 and not any(character in profile for character in profile_prose):
+    # Masked URLs and code retain their length as spaces, so the threshold must
+    # count real prose characters. Native characters anywhere in the complete
+    # text also disprove the specific hypothesis of wholesale ASCII folding.
+    profile_prose_solid = sum(1 for character in profile_prose if not character.isspace())
+    if (profile and profile_prose_solid >= 200
+            and not any(character in profile for character in profile_prose)
+            and not any(character in profile for character in text)):
         findings.append(Finding(
             "missing-language-character-profile",
             f"Long {base_language} text contains none of the language's characteristic native characters; possible wholesale ASCII folding.",

package/standard-skills/translate-native/scripts/check_commercial_review.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Offline evidence-shape check, never a semantic approval or release token."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+from commercial_localization_profile import CommercialReviewBlocked, review_contract, validate_review
+
+
+PROFILE = "translate-native.commercial.v2"
+MAX_INPUT_BYTES = 2_000_000
+
+
+def _read(path: str) -> str:
+    # Bound each read; decode bytes directly to preserve CRLF and exact spans.
+    with Path(path).open("rb") as stream:
+        raw = stream.read(MAX_INPUT_BYTES + 1)
+    if len(raw) > MAX_INPUT_BYTES:
+        raise ValueError("input limit")
+    text = raw.decode("utf-8")
+    if not text.strip() or text.startswith("\ufeff"):
+        raise ValueError("empty input or BOM")
+    return text
+
+
+def _object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate JSON key")
+        result[key] = value
+    return result
+
+
+def _constant(value):
+    raise ValueError("nonfinite JSON number")
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--contract", action="store_true", help="print the review contract; not completed evidence")
+    parser.add_argument("--source", help="complete source text, UTF-8 without BOM")
+    parser.add_argument("--target", help="complete target text, UTF-8 without BOM")
+    parser.add_argument("--review", help="source-aware review JSON, UTF-8 without BOM")
+    args = parser.parse_args(argv)
+    if args.contract:
+        if any((args.source, args.target, args.review)):
+            parser.error("--contract cannot be combined with input files")
+        print(json.dumps({"status": "CONTRACT", "release_allowed": False,
+                          "commercial_review": review_contract(PROFILE)}, ensure_ascii=False))
+        return 0
+    if not all((args.source, args.target, args.review)):
+        parser.error("--source, --target and --review are required")
+    result = {"schema": "translate-native.commercial-evidence-check.v1",
+              "profile": PROFILE, "release_allowed": False}
+    try:
+        source, target, raw_review = (_read(path) for path in (args.source, args.target, args.review))
+        review = json.loads(raw_review, object_pairs_hook=_object, parse_constant=_constant)
+        validate_review(review, source, target, PROFILE)
+    except CommercialReviewBlocked as error:
+        result.update(status="BLOCK", reason=error.code)
+    except (OSError, ValueError, RecursionError):
+        result.update(status="BLOCK", reason="review.commercial.input_invalid")
+    else:
+        result.update(
+            status="EVIDENCE_VALID", reason="independent_quality_and_signed_release_required",
+            source_sha256=hashlib.sha256(source.encode("utf-8")).hexdigest(),
+            target_sha256=hashlib.sha256(target.encode("utf-8")).hexdigest(),
+            review_sha256=hashlib.sha256(raw_review.encode("utf-8")).hexdigest(),
+        )
+    print(json.dumps(result, ensure_ascii=False, sort_keys=True))
+    return 0 if result["status"] == "EVIDENCE_VALID" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,333 @@
+"""Language-neutral commercial review contract; not a semantic language detector.
+
+Models provide semantic evidence. This module validates coverage, exact evidence
+locations and verdict consistency, not the truth of a model's interpretation.
+Only a host-verified quality receipt can authorize subsequent publication.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+
+PUBLIC_PROFILE_SCHEMA = "translate-native.commercial-capabilities.v2"
+REVIEW_SUMMARY_CAPABILITIES_SCHEMA = (
+    "translate-native.commercial-review-summary-capabilities.v1"
+)
+REVIEW_SUMMARY_SCHEMA = "translate-native.commercial-review-summary.v1"
+
+DIMENSIONS = {
+    "amount_currency": "Amounts, currency identity, units and price-to-product association; no conversion or rounding.",
+    "discount_basis": "Discount or saving amount/rate, comparison price, eligibility and reference period.",
+    "qualifiers": "From, up to, only, minimum, maximum, approximate and other limits on every claim.",
+    "tax_status": "Tax included/excluded, stated rates and scope; do not infer local tax treatment.",
+    "billing_interval": "Charge frequency and amount due now, separate from the advertised equivalent monthly price.",
+    "commitment": "Contract duration, minimum commitment, trial duration and whether a trial is paid or free.",
+    "renewal": "Automatic/manual renewal, renewal price, interval and conditions after introductory offers.",
+    "cancellation": "Cancellation deadline, notice period, fees, refund conditions and exceptions.",
+    "conditions": "Every remaining eligibility rule, quantity, tier count, limit, deadline and linked footnote.",
+    "offer_assignment": "Which offer, tier or product each claim belongs to; never accept swapped prices or conditions.",
+}
+
+
+def _canonical_json(value: Any) -> bytes:
+    return json.dumps(
+        value, ensure_ascii=False, sort_keys=True, separators=(",", ":"),
+    ).encode("utf-8")
+
+
+def public_review_summary_contract(profile: str) -> dict[str, Any]:
+    """Return the exact content-free summary contract external adapters consume."""
+    body = {
+        "schema": REVIEW_SUMMARY_CAPABILITIES_SCHEMA,
+        "result_schema": REVIEW_SUMMARY_SCHEMA,
+        "profile": profile,
+        "required_fields": [
+            "schema", "profile", "status", "review_required_dimensions",
+            "evidence_sha256",
+        ],
+        "statuses": {
+            "verified": {"review_required_dimensions": "empty"},
+            "review_required": {
+                "review_required_dimensions": "one-or-more",
+                "requires_independent_review": True,
+            },
+        },
+        "review_required_dimensions": {
+            "allowed": list(DIMENSIONS),
+            "order": list(DIMENSIONS),
+            "unique": True,
+        },
+        "evidence_sha256": {
+            "algorithm": "sha-256",
+            "canonicalization": "utf-8-json-sort-keys-no-insignificant-whitespace",
+            "covers": "complete-commercial-review-evidence",
+        },
+        "content_policy": {
+            "source_text": False,
+            "target_text": False,
+            "source_spans": False,
+            "target_spans": False,
+            "reviewer_prose": False,
+            "project_prices": False,
+            "project_brands": False,
+        },
+    }
+    return {
+        **body,
+        "sha256": hashlib.sha256(_canonical_json(body)).hexdigest(),
+    }
+
+
+def public_profile(profile: str) -> dict[str, Any]:
+    """Return the public, brand-neutral contract implemented by this module."""
+    body = {
+        "schema": PUBLIC_PROFILE_SCHEMA,
+        "profile": profile,
+        "review_summary_schema": REVIEW_SUMMARY_SCHEMA,
+        "review_summary_contract": public_review_summary_contract(profile),
+        "applies_to": {
+            "content_type": "commercial",
+            "locales": "all-supported-target-locales",
+        },
+        "dimensions": [
+            {"name": name, "requirement": requirement}
+            for name, requirement in DIMENSIONS.items()
+        ],
+        "preservation": {
+            "amounts": "exact-value",
+            "currencies": "same-identity-no-conversion",
+            "discounts": "rate-amount-reference-basis-period-and-eligibility",
+            "qualifiers": "scope-and-limit-per-claim",
+            "taxes": "status-rate-and-scope-without-inference",
+            "billing": "charge-amount-and-frequency",
+            "commitment": "separate-duration-and-minimum-term",
+            "renewal": "mode-price-interval-and-conditions",
+            "cancellation": "deadline-notice-fees-refunds-and-exceptions",
+            "conditions": "eligibility-limits-deadlines-footnotes-and-links",
+            "offer_assignment": "every-claim-bound-to-its-own-offer",
+        },
+        "rendering": {
+            "locale_appropriate": True,
+            "natural_wording": True,
+            "native_digits_allowed": True,
+            "number_words_allowed": True,
+            "written_percentages_allowed": True,
+            "locale_separators_allowed": True,
+            "rounding_allowed": False,
+            "currency_conversion_allowed": False,
+            "exact_characters_only_when_project_configured": True,
+        },
+        "verification": {
+            "method": "semantic-provider-evidence",
+            "deterministic_numeric_regex_is_sufficient": False,
+            "evidence_granularity": "every-proposition-per-offer",
+            "directions": ["matched", "source_only", "target_only"],
+            "ambiguous_values": "unresolved",
+            "unresolved_route": "independent-model-or-qualified-native-domain-review",
+            "automatic_publication_when_unresolved": False,
+        },
+        "protected_terms": "project-configuration-only",
+    }
+    return {
+        **body,
+        "sha256": hashlib.sha256(_canonical_json(body)).hexdigest(),
+    }
+
+CREATION_GUIDANCE = """Localize prices, offers and subscriptions as natural native commercial copy.
+Preserve every commercial proposition and its association with the correct offer, not merely a bag of numbers.
+Keep brands, product names and protected slogans exactly as configured for this project; invent no universal list.
+Locale formatting, native digits, number words and written percentages are allowed when semantically equivalent.
+Do not convert currency, change a tax claim, round a price, strengthen a saving or conceal a condition.
+Keep billing frequency distinct from contract length. Preserve footnote and link associations.
+An explicit instruction to preserve exact characters (for example a currency symbol) overrides format adaptation."""
+
+NATIVE_GUIDANCE = """Judge commercial copy as native writing: idiomatic pricing labels, CTAs, natural number,
+currency and interval expressions, unambiguous offer layout and readable conditions. Do not require digits instead
+of number words, ASCII instead of native digits, or source-locale punctuation. Do not infer missing commercial facts."""
+
+FIDELITY_GUIDANCE = """For each commercial dimension inspect the COMPLETE source and candidate, including
+all offers, headings, footnotes, links and conditions. Record every applicable proposition as an item with a stable
+offer label, semantic explanation and relation: 'matched', 'source_only' for an omission, or 'target_only' for an
+addition. Give exact zero-based Python Unicode code-point spans with an exclusive end; the absent side of a one-sided
+item MUST be null. Repeated amounts must stay attached to their own offer; number multisets do not prove fidelity.
+'not_present' is valid only if a dimension is absent from BOTH texts. 'equivalent' requires nonempty matched items
+covering every applicable proposition. A dimension-level 'changed' or 'uncertain' verdict requires at least one
+specific item; use coverage='uncertain' for unresolved overall completeness without inventing a span.
+Use 'changed' for a known defect and 'uncertain' for unresolved interpretation, coverage or insufficient language/domain
+evidence. Use coverage='uncertain' unless every proposition and offer association was checked. Never resolve numeric
+ambiguity by guessing. Number words, written percentages, native digits and locale separators may be equivalent;
+12 months and one year may be equivalent only when the actual commercial terms agree. State the interpretation in
+the explanation. No average score can override a defect. Return commercial_review in addition to the normal review."""
+
+
+class CommercialReviewBlocked(ValueError):
+    def __init__(self, code: str):
+        super().__init__(code)
+        self.code = code
+
+
+def review_contract(schema: str) -> dict[str, Any]:
+    return {
+        "schema": schema,
+        "coverage": "complete or uncertain",
+        "checks": {
+            name: {
+                "status": "equivalent, not_present, changed or uncertain",
+                "items": [{
+                    "offer": "stable offer label",
+                    "relation": "matched, source_only, or target_only",
+                    "source_span": [0, 1],
+                    "target_span": [0, 1],
+                    "explanation": description,
+                }],
+            }
+            for name, description in DIMENSIONS.items()
+        },
+    }
+
+
+def validate_review(
+    value: Any,
+    source: str,
+    target: str,
+    schema: str,
+    *,
+    allow_uncertain: bool = False,
+) -> dict[str, Any]:
+    """Validate evidence and return a content-free, hash-bound routing summary."""
+    def invalid() -> None:
+        raise CommercialReviewBlocked("review.commercial.invalid")
+
+    def span(value: Any, text: str) -> None:
+        if (
+            not isinstance(value, list) or len(value) != 2
+            or any(type(offset) is not int for offset in value)
+            or not 0 <= value[0] < value[1] <= len(text)
+            or not text[value[0]:value[1]].strip()
+        ):
+            invalid()
+
+    if not isinstance(value, dict) or set(value) != {"schema", "coverage", "checks"}:
+        invalid()
+    if value["schema"] != schema or value["coverage"] not in ("complete", "uncertain"):
+        invalid()
+    checks = value["checks"]
+    if not isinstance(checks, dict) or set(checks) != set(DIMENSIONS):
+        invalid()
+    uncertain_dimensions: set[str] = set()
+    coverage_uncertain = value["coverage"] == "uncertain"
+    changed = False
+    evidenced = False
+    for name, check in checks.items():
+        if not isinstance(check, dict) or set(check) != {"status", "items"}:
+            invalid()
+        status, items = check["status"], check["items"]
+        if status not in ("equivalent", "not_present", "changed", "uncertain"):
+            invalid()
+        if not isinstance(items, list) or len(items) > 1000:
+            invalid()
+        if (
+            (status == "not_present" and items)
+            or (status in ("equivalent", "changed", "uncertain") and not items)
+        ):
+            invalid()
+        seen = set()
+        for item in items:
+            if not isinstance(item, dict) or set(item) != {
+                "offer", "relation", "source_span", "target_span", "explanation",
+            }:
+                invalid()
+            for field in ("offer", "explanation"):
+                if not isinstance(item[field], str) or not item[field].strip() or len(item[field]) > 2000:
+                    invalid()
+            relation = item["relation"]
+            if relation == "matched":
+                span(item["source_span"], source)
+                span(item["target_span"], target)
+            elif relation == "source_only":
+                span(item["source_span"], source)
+                if item["target_span"] is not None:
+                    invalid()
+            elif relation == "target_only":
+                if item["source_span"] is not None:
+                    invalid()
+                span(item["target_span"], target)
+            else:
+                invalid()
+            if status == "equivalent" and relation != "matched":
+                invalid()
+            identity = (
+                item["offer"], relation,
+                tuple(item["source_span"]) if item["source_span"] is not None else None,
+                tuple(item["target_span"]) if item["target_span"] is not None else None,
+            )
+            if identity in seen:
+                invalid()
+            seen.add(identity)
+        if status == "uncertain":
+            uncertain_dimensions.add(name)
+        changed |= status == "changed"
+        evidenced |= status == "equivalent"
+    if changed:
+        raise CommercialReviewBlocked("review.commercial.changed")
+    # Every evidenced condition must resolve to an explicitly reviewed offer.
+    assignment = checks["offer_assignment"]
+    if assignment["status"] != "equivalent" or not any(
+        check["status"] == "equivalent" for name, check in checks.items() if name != "offer_assignment"
+    ):
+        uncertain_dimensions.add("offer_assignment")
+    else:
+        offers = {item["offer"] for item in assignment["items"]}
+        if any(item["offer"] not in offers for check in checks.values() for item in check["items"]):
+            invalid()
+    if coverage_uncertain or not evidenced:
+        uncertain_dimensions.update(DIMENSIONS)
+    summary = {
+        "schema": REVIEW_SUMMARY_SCHEMA,
+        "profile": schema,
+        "status": "review_required" if uncertain_dimensions else "verified",
+        "review_required_dimensions": [
+            name for name in DIMENSIONS if name in uncertain_dimensions
+        ],
+        "evidence_sha256": hashlib.sha256(_canonical_json(value)).hexdigest(),
+    }
+    if uncertain_dimensions and not allow_uncertain:
+        raise CommercialReviewBlocked("review.commercial.independent_review_required")
+    return summary
+
+
+def validate_summary(
+    value: Any,
+    profile: str,
+    *,
+    review_required: bool,
+) -> dict[str, Any]:
+    """Validate a persisted summary without retaining customer or reviewer text."""
+    if (
+        not isinstance(value, dict)
+        or set(value) != {
+            "schema", "profile", "status", "review_required_dimensions",
+            "evidence_sha256",
+        }
+        or value["schema"] != REVIEW_SUMMARY_SCHEMA
+        or value["profile"] != profile
+        or value["status"] not in {"verified", "review_required"}
+        or not isinstance(value["evidence_sha256"], str)
+        or len(value["evidence_sha256"]) != 64
+        or any(character not in "0123456789abcdef" for character in value["evidence_sha256"])
+        or not isinstance(value["review_required_dimensions"], list)
+    ):
+        raise CommercialReviewBlocked("review.commercial.summary_invalid")
+    dimensions = value["review_required_dimensions"]
+    if (
+        len(dimensions) != len(set(dimensions))
+        or any(name not in DIMENSIONS for name in dimensions)
+        or dimensions != [name for name in DIMENSIONS if name in dimensions]
+        or (value["status"] == "verified") != (not dimensions)
+        or (value["status"] == "review_required" and not review_required)
+    ):
+        raise CommercialReviewBlocked("review.commercial.summary_invalid")
+    return json.loads(_canonical_json(value))

package/standard-tools/language-guard/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maykbiletti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/standard-tools/language-guard/VERSION

@@ -0,0 +1 @@
+6.64.0

package/standard-tools/language-guard/blun_language_guard.py

@@ -196,7 +196,13 @@ def validate_text(
     base_language = language.casefold().replace("_", "-").split("-", 1)[0]
     profile = LANGUAGE_CHARACTER_PROFILES.get(base_language)
     profile_prose = DIACRITICS.mask_technical_text(text)
-    if profile and len(profile_prose) >= 200 and not any(character in profile for character in profile_prose):
+    # Masked URLs and code retain their length as spaces, so the threshold must
+    # count real prose characters. Native characters anywhere in the complete
+    # text also disprove the specific hypothesis of wholesale ASCII folding.
+    profile_prose_solid = sum(1 for character in profile_prose if not character.isspace())
+    if (profile and profile_prose_solid >= 200
+            and not any(character in profile for character in profile_prose)
+            and not any(character in profile for character in text)):
         findings.append(Finding(
             "missing-language-character-profile",
             f"Long {base_language} text contains none of the language's characteristic native characters; possible wholesale ASCII folding.",