blun-king-cli 9.1.587 → 9.1.588

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

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Portable fail-closed hook: verify a current V6 receipt supplied as JSON on stdin."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+QUALITY_PATH = ROOT / "translate-native" / "scripts" / "language_quality.py"
+SPEC = importlib.util.spec_from_file_location("blun_hook_quality", QUALITY_PATH)
+assert SPEC and SPEC.loader
+QUALITY = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(QUALITY)
+
+
+def load_verification_key(path: Path) -> bytes:
+    """Load an existing verifier key without creating or replacing trust state."""
+    environment_key = os.environ.get("BLUN_LANGUAGE_GUARD_KEY")
+    if environment_key:
+        return hashlib.sha256(environment_key.encode("utf-8")).digest()
+    try:
+        return QUALITY.load_existing_key(path)
+    except FileNotFoundError as error:
+        raise ValueError("signing key is missing; verification fails closed") from error
+    except OSError as error:
+        raise ValueError("signing key cannot be read") from error
+    except ValueError as error:
+        if "permissions" in str(error):
+            raise ValueError("signing key permissions are broader than owner-only") from error
+        raise ValueError("signing key is invalid") from error
+
+
+def main() -> int:
+    try:
+        request = json.loads(sys.stdin.read().lstrip("\ufeff"))
+        task_kind = request["task_kind"]
+        source = request.get("source_text", "")
+        if task_kind not in {"translation", "response"}:
+            raise ValueError("task_kind must be translation or response")
+        if task_kind == "translation" and not source.strip():
+            raise ValueError("translation receipts require source_text")
+        if task_kind == "response" and source.strip():
+            raise ValueError("response receipts cannot carry source_text")
+        key_path = Path(os.environ.get("BLUN_LANGUAGE_GUARD_KEY_FILE", Path.home() / ".config" / "blun-language-guard" / "signing.key"))
+        result = QUALITY.verify_receipt(
+            request["release_token"], source, request["target_text"],
+            request["language"], load_verification_key(key_path),
+            request.get("content_type", "prose"), request.get("short_text_reviewed") is True,
+            purpose=task_kind,
+        )
+    except (KeyError, ValueError, json.JSONDecodeError, OSError) as error:
+        print(json.dumps({"allow": False, "error": str(error)}))
+        return 1
+    print(json.dumps({"allow": result["valid"], "verification": result}))
+    return 0 if result["valid"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Host-owned routing from structured job metadata to the correct release gate."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+
+EXACT_LANGUAGE = re.compile(r"^(?:[A-Za-z]{2,8}|x)(?:-[A-Za-z0-9]{1,8})*$")
+TRANSLATION_OPERATIONS = {
+    "translate", "translation", "localize", "localization", "transcreate",
+    "translation-review", "translation-proofread", "i18n", "l10n",
+}
+RESPONSE_OPERATIONS = {"respond", "response", "chat", "answer", "compose"}
+
+
+class RoutingBlocked(ValueError):
+    """Raised when trusted job metadata is contradictory or incomplete."""
+
+
+@dataclass(frozen=True)
+class Route:
+    task_kind: str
+    language: str
+    source_text: str
+    content_type: str
+    reason: str
+
+
+def _string(context: dict[str, Any], name: str) -> str:
+    value = context.get(name, "")
+    if value is None:
+        return ""
+    if not isinstance(value, str):
+        raise RoutingBlocked(f"{name} must be a string")
+    return value
+
+
+def route_host_context(context: dict[str, Any]) -> Route:
+    if not isinstance(context, dict):
+        raise RoutingBlocked("host context must be an object")
+    explicit = _string(context, "task_kind").strip().casefold()
+    operation = _string(context, "operation").strip().casefold()
+    source = _string(context, "source_text")
+    content_type = _string(context, "content_type").strip() or "prose"
+    if content_type not in {"prose", "title", "meta_description", "ui"}:
+        raise RoutingBlocked("invalid content_type")
+
+    translation_evidence = bool(source.strip()) or operation in TRANSLATION_OPERATIONS
+    if explicit:
+        if explicit not in {"response", "translation"}:
+            raise RoutingBlocked("invalid task_kind")
+        task_kind = explicit
+        reason = "explicit-host-task-kind"
+    elif translation_evidence:
+        task_kind = "translation"
+        reason = "structured-translation-evidence"
+    elif not operation or operation in RESPONSE_OPERATIONS:
+        task_kind = "response"
+        reason = "structured-response-route"
+    else:
+        raise RoutingBlocked("unknown host operation")
+
+    if task_kind == "translation" and not source.strip():
+        raise RoutingBlocked("translation route requires complete source_text")
+    if task_kind == "response" and source.strip():
+        raise RoutingBlocked("source_text cannot be downgraded to response")
+    if task_kind == "response" and operation in TRANSLATION_OPERATIONS:
+        raise RoutingBlocked("translation operation cannot be downgraded to response")
+    if task_kind == "translation" and operation in RESPONSE_OPERATIONS:
+        raise RoutingBlocked("response operation conflicts with translation source")
+
+    language_field = "target_language" if task_kind == "translation" else "response_language"
+    language = _string(context, language_field).strip() or _string(context, "language").strip()
+    if language.casefold() in {"auto", "all"} or not EXACT_LANGUAGE.fullmatch(language):
+        raise RoutingBlocked(f"{language_field} must be an exact language or locale tag")
+    return Route(task_kind, language, source if task_kind == "translation" else "", content_type, reason)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Resolve trusted host metadata to a language-guard route")
+    parser.add_argument("--input", type=Path)
+    args = parser.parse_args()
+    try:
+        raw = args.input.read_text(encoding="utf-8-sig") if args.input else sys.stdin.read().lstrip("\ufeff")
+        route = route_host_context(json.loads(raw))
+    except (OSError, json.JSONDecodeError, RoutingBlocked) as error:
+        print(json.dumps({"status": "BLOCK", "error": str(error)}))
+        return 1
+    print(json.dumps({"status": "PASS", **asdict(route)}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""Deterministic, provider-neutral planning for EU website localization jobs.
+
+The planner does not call a model or publish content. It turns one trusted
+website source object into one independently retryable job per target locale.
+Every job key is bound to the source and all policy inputs that can affect the
+result, so a queue can safely deduplicate retries without reusing stale copy.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import re
+import sys
+import unicodedata
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+
+
+SCHEMA = "blun.website-localization-plan.v2"
+JOB_SCHEMA = "blun.website-localization-job.v2"
+EU_LANGUAGE_SOURCE = (
+    "https://european-union.europa.eu/principles-countries-history/languages_en"
+)
+MAX_SOURCE_BYTES = 1_000_000
+MAX_FIELD_LENGTH = 256
+EXACT_LOCALE = re.compile(
+    r"^[A-Za-z]{2,8}(?:-(?:[A-Za-z]{4}|[A-Za-z]{2}|[0-9]{3}|[A-Za-z0-9]{5,8}))*$"
+)
+CONTENT_TYPES = frozenset({
+    "headline",
+    "cta",
+    "marketing",
+    "ui",
+    "documentation",
+    "seo",
+    "legal",
+    "commercial",
+})
+QUALITY_PASSES = ("target_native", "source_fidelity")
+COMMERCIAL_PROFILE = "translate-native.commercial.v2"
+
+
+class LocalizationPlanBlocked(ValueError):
+    """Raised when trusted localization metadata is incomplete or ambiguous."""
+
+
+@dataclass(frozen=True)
+class LocaleProfile:
+    locale: str
+    eu_code: str
+    language: str
+    native_name: str
+    script: str
+    quality_profile_version: str
+    quality_profile_sha256: str
+    direction: str = "ltr"
+
+
+# The European Union currently has 24 official languages. A single explicit
+# website locale is selected for each language so every queue item has regional
+# conventions rather than an ambiguous bare language tag. This public default
+# uses Austrian German; projects can introduce other regional profiles in a
+# future schema revision without embedding brand-specific vocabulary here.
+def _load_quality_profiles():
+    path = Path(__file__).with_name("website_localization_quality_profiles.py")
+    spec = importlib.util.spec_from_file_location("blun_website_quality_profiles", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError("cannot load website-localization quality profiles")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_QUALITY_PROFILES = _load_quality_profiles()
+
+
+def _locale(locale: str, eu_code: str, language: str, native_name: str, script: str) -> LocaleProfile:
+    quality = _QUALITY_PROFILES.quality_profile_for(locale)
+    return LocaleProfile(
+        locale, eu_code, language, native_name, script,
+        quality["version"], quality["sha256"],
+    )
+
+
+EU_OFFICIAL_LOCALES: tuple[LocaleProfile, ...] = (
+    _locale("bg-BG", "BG", "bg", "български", "Cyrl"),
+    _locale("hr-HR", "HR", "hr", "hrvatski", "Latn"),
+    _locale("cs-CZ", "CS", "cs", "čeština", "Latn"),
+    _locale("da-DK", "DA", "da", "dansk", "Latn"),
+    _locale("nl-NL", "NL", "nl", "Nederlands", "Latn"),
+    _locale("en-IE", "EN", "en", "English", "Latn"),
+    _locale("et-EE", "ET", "et", "eesti", "Latn"),
+    _locale("fi-FI", "FI", "fi", "suomi", "Latn"),
+    _locale("fr-FR", "FR", "fr", "français", "Latn"),
+    _locale("de-AT", "DE", "de", "Deutsch", "Latn"),
+    _locale("el-GR", "EL", "el", "ελληνικά", "Grek"),
+    _locale("hu-HU", "HU", "hu", "magyar", "Latn"),
+    _locale("ga-IE", "GA", "ga", "Gaeilge", "Latn"),
+    _locale("it-IT", "IT", "it", "italiano", "Latn"),
+    _locale("lv-LV", "LV", "lv", "latviešu", "Latn"),
+    _locale("lt-LT", "LT", "lt", "lietuvių", "Latn"),
+    _locale("mt-MT", "MT", "mt", "Malti", "Latn"),
+    _locale("pl-PL", "PL", "pl", "polski", "Latn"),
+    _locale("pt-PT", "PT", "pt", "português", "Latn"),
+    _locale("ro-RO", "RO", "ro", "română", "Latn"),
+    _locale("sk-SK", "SK", "sk", "slovenčina", "Latn"),
+    _locale("sl-SI", "SL", "sl", "slovenščina", "Latn"),
+    _locale("es-ES", "ES", "es", "español", "Latn"),
+    _locale("sv-SE", "SV", "sv", "svenska", "Latn"),
+)
+_PROFILE_BY_LOCALE = {profile.locale: profile for profile in EU_OFFICIAL_LOCALES}
+if set(_PROFILE_BY_LOCALE) != {profile.locale for profile in _QUALITY_PROFILES.PROFILES}:
+    raise RuntimeError("EU locale and quality-profile registries differ")
+
+
+def quality_profile_for(locale: str) -> dict[str, Any]:
+    return _QUALITY_PROFILES.quality_profile_for(locale)
+
+
+@dataclass(frozen=True)
+class LocalizationJob:
+    job_id: str
+    source_id: str
+    source_revision: str
+    source_text: str
+    source_hash: str
+    source_locale: str
+    target: LocaleProfile
+    content_type: str
+    glossary_version: str
+    policy_version: str
+    provider_id: str
+    model_id: str
+    model_version: str
+    software_version: str
+
+    def as_payload(self) -> dict[str, Any]:
+        """Return the provider-neutral queue payload for one target locale."""
+        return {
+            "schema": JOB_SCHEMA,
+            "job_id": self.job_id,
+            "idempotency_key": self.job_id,
+            "source": {
+                "id": self.source_id,
+                "revision": self.source_revision,
+                "text": self.source_text,
+                "sha256": self.source_hash,
+                "locale": self.source_locale,
+            },
+            "target": asdict(self.target),
+            "content_type": self.content_type,
+            "glossary_version": self.glossary_version,
+            "policy_version": self.policy_version,
+            "provider": {
+                "id": self.provider_id,
+                "model_id": self.model_id,
+                "model_version": self.model_version,
+            },
+            "software_version": self.software_version,
+            "quality_passes": list(QUALITY_PASSES),
+            "release_required": True,
+            **({"commercial_profile": COMMERCIAL_PROFILE} if self.content_type == "commercial" else {}),
+        }
+
+
+@dataclass(frozen=True)
+class LocalizationPlan:
+    plan_id: str
+    source_hash: str
+    source_locale: str
+    jobs: tuple[LocalizationJob, ...]
+
+    def as_payload(self) -> dict[str, Any]:
+        return {
+            "schema": SCHEMA,
+            "plan_id": self.plan_id,
+            "source_hash": self.source_hash,
+            "source_locale": self.source_locale,
+            "job_count": len(self.jobs),
+            "jobs": [job.as_payload() for job in self.jobs],
+        }
+
+
+def _canonical_json(value: Mapping[str, Any]) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        allow_nan=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+
+
+def _digest(value: Mapping[str, Any]) -> str:
+    return hashlib.sha256(_canonical_json(value)).hexdigest()
+
+
+def _bound_field(name: str, value: Any) -> str:
+    if not isinstance(value, str):
+        raise LocalizationPlanBlocked(f"{name} must be a string")
+    if not value or value != value.strip():
+        raise LocalizationPlanBlocked(f"{name} must be non-empty without surrounding whitespace")
+    if "\x00" in value or len(value) > MAX_FIELD_LENGTH:
+        raise LocalizationPlanBlocked(f"{name} is invalid or too long")
+    if not unicodedata.is_normalized("NFC", value):
+        raise LocalizationPlanBlocked(f"{name} must use NFC Unicode")
+    return value
+
+
+def _source_text(value: Any) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise LocalizationPlanBlocked("source_text must be a non-empty string")
+    if "\x00" in value:
+        raise LocalizationPlanBlocked("source_text contains NUL")
+    if not unicodedata.is_normalized("NFC", value):
+        raise LocalizationPlanBlocked("source_text must use NFC Unicode")
+    if len(value.encode("utf-8")) > MAX_SOURCE_BYTES:
+        raise LocalizationPlanBlocked("source_text exceeds the byte limit")
+    return value
+
+
+def canonicalize_locale(value: Any) -> str:
+    value = _bound_field("locale", value)
+    if value.casefold() in {"auto", "all"}:
+        raise LocalizationPlanBlocked("locale must name one exact language or locale")
+    if not EXACT_LOCALE.fullmatch(value):
+        raise LocalizationPlanBlocked("locale must be an exact BCP-47 language tag")
+    parts = value.split("-")
+    canonical = [parts[0].lower()]
+    for part in parts[1:]:
+        if len(part) == 4 and part.isalpha():
+            canonical.append(part.title())
+        elif (len(part) == 2 and part.isalpha()) or (len(part) == 3 and part.isdigit()):
+            canonical.append(part.upper())
+        else:
+            canonical.append(part.lower())
+    return "-".join(canonical)
+
+
+def _target_profiles(
+    source_locale: str,
+    target_locales: Iterable[Any] | None,
+) -> tuple[LocaleProfile, ...]:
+    source_language = source_locale.split("-", 1)[0]
+    if target_locales is None:
+        return tuple(
+            profile for profile in EU_OFFICIAL_LOCALES
+            if profile.language != source_language
+        )
+    if isinstance(target_locales, (str, bytes)):
+        raise LocalizationPlanBlocked("target_locales must be an array")
+    requested = list(target_locales)
+    if not requested:
+        raise LocalizationPlanBlocked("target_locales must not be empty")
+    canonical = [canonicalize_locale(item) for item in requested]
+    if len(set(canonical)) != len(canonical):
+        raise LocalizationPlanBlocked("target_locales contains duplicates")
+    unknown = [locale for locale in canonical if locale not in _PROFILE_BY_LOCALE]
+    if unknown:
+        raise LocalizationPlanBlocked(
+            "target_locales contains unsupported EU locale: " + ", ".join(unknown)
+        )
+    if any(_PROFILE_BY_LOCALE[locale].language == source_language for locale in canonical):
+        raise LocalizationPlanBlocked("target_locales must exclude the source language")
+    selected = set(canonical)
+    return tuple(profile for profile in EU_OFFICIAL_LOCALES if profile.locale in selected)
+
+
+def plan_website_localization(
+    *,
+    source_id: Any,
+    source_revision: Any,
+    source_text: Any,
+    source_locale: Any,
+    content_type: Any,
+    glossary_version: Any,
+    policy_version: Any,
+    provider_id: Any,
+    model_id: Any,
+    model_version: Any,
+    software_version: Any,
+    target_locales: Iterable[Any] | None = None,
+) -> LocalizationPlan:
+    """Create one deterministic, independently releasable job per EU locale."""
+    source_id = _bound_field("source_id", source_id)
+    source_revision = _bound_field("source_revision", source_revision)
+    source_text = _source_text(source_text)
+    source_locale = canonicalize_locale(source_locale)
+    content_type = _bound_field("content_type", content_type)
+    if content_type not in CONTENT_TYPES:
+        raise LocalizationPlanBlocked("content_type is not a supported website content type")
+    glossary_version = _bound_field("glossary_version", glossary_version)
+    policy_version = _bound_field("policy_version", policy_version)
+    provider_id = _bound_field("provider_id", provider_id)
+    model_id = _bound_field("model_id", model_id)
+    model_version = _bound_field("model_version", model_version)
+    software_version = _bound_field("software_version", software_version)
+    profiles = _target_profiles(source_locale, target_locales)
+    source_hash = hashlib.sha256(source_text.encode("utf-8")).hexdigest()
+
+    common = {
+        "schema": JOB_SCHEMA,
+        "source_id": source_id,
+        "source_revision": source_revision,
+        "source_hash": source_hash,
+        "source_locale": source_locale,
+        "content_type": content_type,
+        "glossary_version": glossary_version,
+        "policy_version": policy_version,
+        "provider_id": provider_id,
+        "model_id": model_id,
+        "model_version": model_version,
+        "software_version": software_version,
+        "quality_passes": QUALITY_PASSES,
+    }
+    if content_type == "commercial":
+        common["commercial_profile"] = COMMERCIAL_PROFILE
+    jobs = tuple(
+        LocalizationJob(
+            job_id="blun-l10n-" + _digest({**common, "target": asdict(profile)}),
+            source_id=source_id,
+            source_revision=source_revision,
+            source_text=source_text,
+            source_hash=source_hash,
+            source_locale=source_locale,
+            target=profile,
+            content_type=content_type,
+            glossary_version=glossary_version,
+            policy_version=policy_version,
+            provider_id=provider_id,
+            model_id=model_id,
+            model_version=model_version,
+            software_version=software_version,
+        )
+        for profile in profiles
+    )
+    plan_binding = {
+        **common,
+        "target_locales": [job.target.locale for job in jobs],
+        "job_ids": [job.job_id for job in jobs],
+    }
+    return LocalizationPlan(
+        plan_id="blun-l10n-plan-" + _digest(plan_binding),
+        source_hash=source_hash,
+        source_locale=source_locale,
+        jobs=jobs,
+    )
+
+
+_PLAN_FIELDS = frozenset({
+    "source_id",
+    "source_revision",
+    "source_text",
+    "source_locale",
+    "content_type",
+    "glossary_version",
+    "policy_version",
+    "provider_id",
+    "model_id",
+    "model_version",
+    "software_version",
+    "target_locales",
+})
+
+
+def plan_from_mapping(value: Any) -> LocalizationPlan:
+    if not isinstance(value, dict):
+        raise LocalizationPlanBlocked("input must be a JSON object")
+    unknown = sorted(set(value) - _PLAN_FIELDS)
+    if unknown:
+        raise LocalizationPlanBlocked("input contains unknown fields: " + ", ".join(unknown))
+    missing = sorted((_PLAN_FIELDS - {"target_locales"}) - set(value))
+    if missing:
+        raise LocalizationPlanBlocked("input is missing fields: " + ", ".join(missing))
+    return plan_website_localization(**value)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Create deterministic EU website-localization queue jobs",
+    )
+    parser.add_argument("--input", type=Path, help="JSON request; defaults to stdin")
+    args = parser.parse_args(argv)
+    try:
+        raw = args.input.read_text(encoding="utf-8-sig") if args.input else sys.stdin.read().lstrip("\ufeff")
+        plan = plan_from_mapping(json.loads(raw))
+    except (OSError, json.JSONDecodeError, LocalizationPlanBlocked) as error:
+        print(json.dumps({"status": "BLOCK", "error": str(error)}, ensure_ascii=False))
+        return 1
+    print(json.dumps({"status": "PASS", **plan.as_payload()}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())