blun-king-cli 9.1.6 → 9.1.8

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

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""Flag common ASCII substitutions and non-NFC text in prose files."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+import unicodedata
+from pathlib import Path
+
+
+RULES: dict[str, tuple[tuple[str, str], ...]] = {
+    "de": (
+        (r"\bfuer\b", "für"),
+        (r"\bueber", "über…"),
+        (r"\bzurueck", "zurück…"),
+        (r"\bmuess", "müss…"),
+        (r"\bkoenn", "könn…"),
+        (r"\bmoech", "möch…"),
+        (r"\bschoen", "schön…"),
+        (r"\bgrues", "grüß…"),
+        (r"\bkoeln\b", "Köln"),
+        (r"\bgroess", "größ…"),
+        (r"\baender", "änder…"),
+        (r"\bpruef", "prüf…"),
+        (r"\bgepruef", "geprüf…"),
+        (r"\buebersetz", "übersetz…"),
+        (r"\boeffn", "öffn…"),
+        (r"\bloesch", "lösch…"),
+        (r"\bwaehr", "währ…"),
+        (r"\bwaer(?:e|en|st|t)\b", "wär…"),
+        (r"\bhaett", "hätt…"),
+        (r"\bwuerd", "würd…"),
+        (r"\bduerf", "dürf…"),
+        (r"\berklaer", "erklär…"),
+        (r"\bgeklaer", "geklär…"),
+        (r"\bnaechst", "nächst…"),
+        (r"\bspaet", "spät…"),
+        (r"\bfrueh", "früh…"),
+        (r"\bwuensch", "wünsch…"),
+        (r"\bgueltig", "gültig…"),
+        (r"\bzuverlaess", "zuverläss…"),
+        (r"\bhaeufig", "häufig…"),
+        (r"\bzusaetz", "zusätz…"),
+        (r"\bvollstaendig", "vollständig…"),
+        (r"\bpersoenlich", "persönlich…"),
+        (r"\bnatuerlich", "natürlich…"),
+        (r"\bmoeglich", "möglich…"),
+        (r"\bnoetig", "nötig…"),
+        (r"\baehnlich", "ähnlich…"),
+        (r"\bgehoer", "gehör…"),
+        (r"\benthaelt", "enthält"),
+        (r"\bwaehl", "wähl…"),
+        (r"\bveroeffent", "veröffent…"),
+        (r"\bunterstuetz", "unterstütz…"),
+        (r"\bbestaet", "bestät…"),
+        (r"\bergaenz", "ergänz…"),
+    ),
+    "sv": (
+        (r"\bGoteborg\b", "Göteborg"),
+        (r"\bMalmo\b", "Malmö"),
+        (r"\bOresund\b", "Öresund"),
+        (r"\bsmorgasbord\b", "smörgåsbord"),
+        (r"\bAngstrom\b", "Ångström"),
+        (r"\bforstar\b", "förstår"),
+        (r"\bbehover\b", "behöver"),
+        (r"\bmojlig", "möjlig…"),
+        (r"\bborja", "börja…"),
+        (r"\bfraga", "fråga…"),
+        (r"\bsjalv", "själv…"),
+        (r"\bhar ar\b", "här är"),
+        (r"\bdet ar\b", "det är"),
+        (r"\bjag ar\b", "jag är"),
+        (r"\bvi ar\b", "vi är"),
+        (r"\bdu ar\b", "du är"),
+        (r"\bar det\b", "är det"),
+        (r"\bfor att\b", "för att"),
+        (r"\bfor dig\b", "för dig"),
+        (r"\bfor er\b", "för er"),
+        (r"\bpa en\b", "på en"),
+        (r"\bpa ett\b", "på ett"),
+        (r"\bpa den\b", "på den"),
+        (r"\bpa det\b", "på det"),
+        (r"\bsprak", "språk…"),
+        (r"\boppn", "öppn…"),
+    ),
+    "es": (
+        (r"\bespanol\b", "español"),
+        (r"\bsenor", "señor…"),
+        (r"\binformacion\b", "información"),
+        (r"\btambien\b", "también"),
+        (r"\bpagina\b", "página"),
+        (r"\bnumero\b", "número"),
+        (r"\badios\b", "adiós"),
+        (r"\bQue\?", "¿Qué?"),
+    ),
+    "fr": (
+        (r"\bfrancais\b", "français"),
+        (r"\becole\b", "école"),
+        (r"\bcreme brulee\b", "crème brûlée"),
+        (r"\btres\b", "très"),
+        (r"\bdeja\b", "déjà"),
+        (r"\betre\b", "être"),
+    ),
+    "pt": (
+        (r"\bSao Paulo\b", "São Paulo"),
+        (r"\bcoracao\b", "coração"),
+        (r"\bportugues\b", "português"),
+        (r"\bvoce\b", "você"),
+        (r"\bnao\b", "não"),
+    ),
+    "it": (
+        (r"\bperche\b", "perché"),
+        (r"\bcitta\b", "città"),
+        (r"\bpiu\b", "più"),
+    ),
+    "da": (
+        (r"\bKobenhavn\b", "København"),
+        (r"\bvaer", "vær…"),
+        (r"\bsprogforstaelse\b", "sprogforståelse"),
+    ),
+    "no": (
+        (r"\bvaer", "vær…"),
+        (r"\bforsta", "forstå…"),
+        (r"\bsporsmal\b", "spørsmål"),
+    ),
+    "is": (
+        (r"\bReykjavik\b", "Reykjavík"),
+        (r"\bThingvellir\b", "Þingvellir"),
+        (r"\bislenska\b", "íslenska"),
+    ),
+    "cs": (
+        (r"\bcestina\b", "čeština"),
+        (r"\bcesk", "česk…"),
+        (r"\bprilis\b", "příliš"),
+        (r"\bDvorak\b", "Dvořák"),
+        (r"\bdekuji\b", "děkuji"),
+        (r"\bmesto\b", "město"),
+    ),
+    "sk": (
+        (r"\bslovencina\b", "slovenčina"),
+        (r"\bdakujem\b", "ďakujem"),
+    ),
+    "pl": (
+        (r"\bLodz\b", "Łódź"),
+        (r"\bjezyk\b", "język"),
+        (r"\bdziekuje\b", "dziękuję"),
+        (r"\bzolty\b", "żółty"),
+    ),
+    "hu": (
+        (r"\bMagyarorszag\b", "Magyarország"),
+        (r"\bkoszonom\b", "köszönöm"),
+        (r"\borom\b", "öröm"),
+    ),
+    "ro": (
+        (r"\bromana\b", "română"),
+        (r"\bBucuresti\b", "București"),
+        (r"\bmultumesc\b", "mulțumesc"),
+        (r"\btara\b", "țară"),
+    ),
+    "tr": (
+        (r"\bIstanbul\b", "İstanbul"),
+        (r"\bTurkce\b", "Türkçe"),
+        (r"\btesekkur", "teşekkür…"),
+        (r"\bgorusuruz\b", "görüşürüz"),
+    ),
+    "hr": (
+        (r"\bDorde\b", "Đorđe"),
+        (r"\bvec\b", "već"),
+        (r"\bcovjek\b", "čovjek"),
+    ),
+    "bs": (
+        (r"\bDorde\b", "Đorđe"),
+        (r"\bvec\b", "već"),
+        (r"\bcovjek\b", "čovjek"),
+    ),
+    "sr": (
+        (r"\bDorde\b", "Đorđe"),
+        (r"\bvec\b", "već"),
+        (r"\bcovek\b", "čovek"),
+    ),
+    "sl": (
+        (r"\bslovenscina\b", "slovenščina"),
+        (r"\bzivjo\b", "živjo"),
+    ),
+    "nl": (
+        (r"\bgeinteresseerd\b", "geïnteresseerd"),
+    ),
+    "fi": (
+        (r"\bhyvaa\b", "hyvää"),
+        (r"\bpaiva\b", "päivä"),
+    ),
+    "et": (
+        (r"\bTonu\b", "Tõnu"),
+        (r"\bvoimalik\b", "võimalik"),
+    ),
+    "lv": (
+        (r"\bRiga\b", "Rīga"),
+        (r"\blatviesu\b", "latviešu"),
+    ),
+    "lt": (
+        (r"\blietuviu\b", "lietuvių"),
+        (r"\baciu\b", "ačiū"),
+    ),
+    "vi": (
+        (r"\bTieng Viet\b", "Tiếng Việt"),
+        (r"\bcam on\b", "cảm ơn"),
+        (r"\bViet Nam\b", "Việt Nam"),
+    ),
+    "ca": (
+        (r"\bcatala\b", "català"),
+        (r"\bcollegi\b", "col·legi"),
+    ),
+    "ga": (
+        (r"\bSlainte\b", "Sláinte"),
+        (r"\bfailte\b", "fáilte"),
+    ),
+    "mt": (
+        (r"\bghaliex\b", "għaliex"),
+    ),
+    "sq": (
+        (r"\bShqiperi\b", "Shqipëri"),
+    ),
+}
+
+LANGUAGE_MARKERS: dict[str, tuple[str, ...]] = {
+    "de": (" der ", " die ", " das ", " und ", " ist ", " nicht ", " ich ", " wir ", " mit "),
+    "sv": (" den ", " det ", " och ", " att ", " är ", " inte ", " jag ", " vi ", " med "),
+    "es": (" el ", " la ", " los ", " las ", " que ", " una ", " con ", " para "),
+    "fr": (" le ", " la ", " les ", " des ", " est ", " une ", " avec ", " pour "),
+    "pt": (" o ", " os ", " uma ", " que ", " com ", " para ", " não "),
+    "it": (" il ", " lo ", " gli ", " che ", " una ", " con ", " per "),
+    "da": (" den ", " det ", " og ", " ikke ", " jeg ", " med ", " til "),
+    "no": (" den ", " det ", " og ", " ikke ", " jeg ", " med ", " til "),
+    "is": (" og ", " ekki ", " ég ", " með ", " til ", " sem "),
+    "cs": (" ten ", " tato ", " a ", " že ", " není ", " jsem ", " pro "),
+    "sk": (" ten ", " táto ", " a ", " že ", " nie ", " som ", " pre "),
+    "pl": (" ten ", " ta ", " i ", " że ", " nie ", " jest ", " dla "),
+    "hu": (" az ", " egy ", " és ", " nem ", " van ", " hogy "),
+    "ro": (" un ", " o ", " și ", " nu ", " este ", " pentru "),
+    "tr": (" bu ", " bir ", " ve ", " değil ", " için ", " ile "),
+    "hr": (" ovaj ", " jedna ", " i ", " nije ", " za ", " sa "),
+    "bs": (" ovaj ", " jedna ", " i ", " nije ", " za ", " sa "),
+    "sr": (" ovaj ", " jedna ", " i ", " nije ", " za ", " sa "),
+    "sl": (" ta ", " ena ", " in ", " ni ", " za ", " je "),
+    "nl": (" de ", " het ", " een ", " en ", " niet ", " voor "),
+    "fi": (" tämä ", " yksi ", " ja ", " ei ", " on ", " varten "),
+    "et": (" see ", " üks ", " ja ", " ei ", " on ", " jaoks "),
+    "lv": (" tas ", " viena ", " un ", " nav ", " ir ", " par "),
+    "lt": (" tai ", " viena ", " ir ", " nėra ", " yra ", " už "),
+    "vi": (" một ", " và ", " không ", " là ", " cho ", " của "),
+    "ca": (" el ", " la ", " els ", " una ", " amb ", " per "),
+    "ga": (" an ", " na ", " agus ", " ní ", " tá ", " le "),
+    "mt": (" il ", " u ", " mhux ", " huwa ", " għal "),
+    "sq": (" ky ", " një ", " dhe ", " nuk ", " është ", " për "),
+}
+
+
+def mask_technical_text(text: str) -> str:
+    """Mask common technical spans while retaining line positions."""
+    patterns = (
+        r"```.*?```",
+        r"`[^`\n]+`",
+        r"https?://\S+",
+        r"\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b",
+    )
+    masked = text
+    for pattern in patterns:
+        masked = re.sub(
+            pattern,
+            lambda match: "".join("\n" if char == "\n" else " " for char in match.group(0)),
+            masked,
+            flags=re.DOTALL,
+        )
+    return masked
+
+
+def detect_languages(text: str) -> tuple[str, ...]:
+    padded = f" {text.casefold()} "
+    scores = {
+        language: sum(padded.count(marker) for marker in markers)
+        for language, markers in LANGUAGE_MARKERS.items()
+    }
+    best = max(scores.values(), default=0)
+    if best == 0:
+        return ()
+    return tuple(language for language, score in scores.items() if score == best)
+
+
+def iter_findings(text: str, languages: tuple[str, ...]):
+    for language in languages:
+        for pattern, suggestion in RULES[language]:
+            for match in re.finditer(pattern, text, flags=re.IGNORECASE):
+                line = text.count("\n", 0, match.start()) + 1
+                yield line, language, match.group(0), suggestion
+
+
+def check_file(path: Path, language: str) -> int:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        print(f"{path}: not valid UTF-8", file=sys.stderr)
+        return 1
+    except OSError as error:
+        print(f"{path}: {error}", file=sys.stderr)
+        return 1
+
+    status = 0
+    if text != unicodedata.normalize("NFC", text):
+        print(f"{path}: Unicode text is not NFC-normalized")
+        status = 1
+
+    prose = mask_technical_text(text)
+    normalized_language = language.casefold().split("-", 1)[0].split("_", 1)[0]
+    if language == "auto":
+        languages = detect_languages(prose)
+    elif language == "all":
+        languages = tuple(RULES)
+    elif normalized_language not in RULES:
+        languages = ()
+        print(
+            f"{path}: no deterministic diacritics rules for {language!r}; "
+            "Unicode NFC passed, but the native-orthography review is still required."
+        )
+    else:
+        languages = (normalized_language,)
+    for line, code, found, suggestion in iter_findings(prose, languages):
+        print(f"{path}:{line}: [{code}] {found!r} -> check {suggestion!r}")
+        status = 1
+    return status
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Flag common missing diacritics in UTF-8 prose files."
+    )
+    parser.add_argument("files", nargs="+", type=Path)
+    parser.add_argument(
+        "--language",
+        default="auto",
+        help=(
+            "target language or BCP 47 tag; unsupported languages still receive "
+            "Unicode checks and exit successfully when clean; default: auto"
+        ),
+    )
+    args = parser.parse_args()
+
+    return max(check_file(path, args.language) for path in args.files)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Zero-dependency client for the isolated BLUN Language Guard service."""
+
+from __future__ import annotations
+
+import json
+import socket
+from typing import Any
+
+
+MAX_RESPONSE_BYTES = 8 * 1024 * 1024
+
+
+class GuardServiceError(RuntimeError):
+    """Raised when the isolated guard cannot evaluate a request safely."""
+
+
+def parse_endpoint(endpoint: str) -> tuple[str, str | tuple[str, int]]:
+    value = str(endpoint or "").strip()
+    if value.startswith("unix:") and value[5:]:
+        return "unix", value[5:]
+    if value.startswith("tcp:"):
+        host_port = value[4:]
+        host, separator, raw_port = host_port.rpartition(":")
+        if separator and host in {"127.0.0.1", "localhost", "::1"}:
+            try:
+                port = int(raw_port)
+            except ValueError as error:
+                raise GuardServiceError("invalid guard service TCP port") from error
+            if 1 <= port <= 65535:
+                return "tcp", (host, port)
+    raise GuardServiceError("guard service endpoint must be unix:/path or loopback tcp:host:port")
+
+
+def call_guard_service(
+    endpoint: str,
+    request: dict[str, Any],
+    *,
+    auth_token: str = "",
+    timeout: float = 10.0,
+) -> dict[str, Any]:
+    transport, address = parse_endpoint(endpoint)
+    payload = dict(request)
+    if auth_token:
+        payload["service_token"] = auth_token
+    encoded = (json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + "\n").encode("utf-8")
+    if len(encoded) > MAX_RESPONSE_BYTES:
+        raise GuardServiceError("guard service request is too large")
+    try:
+        if transport == "unix":
+            if not hasattr(socket, "AF_UNIX"):
+                raise GuardServiceError("Unix sockets are unavailable on this platform")
+            client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        else:
+            client = socket.create_connection(address, timeout=timeout)
+        with client:
+            client.settimeout(timeout)
+            if transport == "unix":
+                client.connect(address)
+            client.sendall(encoded)
+            chunks: list[bytes] = []
+            size = 0
+            while True:
+                chunk = client.recv(65536)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                size += len(chunk)
+                if size > MAX_RESPONSE_BYTES:
+                    raise GuardServiceError("guard service response is too large")
+                if b"\n" in chunk:
+                    break
+    except (OSError, TimeoutError) as error:
+        raise GuardServiceError("guard service is unavailable") from error
+    raw = b"".join(chunks).split(b"\n", 1)[0]
+    try:
+        response = json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise GuardServiceError("guard service returned an invalid response") from error
+    if not isinstance(response, dict):
+        raise GuardServiceError("guard service response must be an object")
+    return response

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

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Language identity, bidi, glossary, and signed release-receipt primitives."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import re
+import time
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+
+VERSION = "6.20.0"
+DANGEROUS_BIDI = {"\u202a", "\u202b", "\u202c", "\u202d", "\u202e"}
+ISOLATE_OPENERS = {"\u2066", "\u2067", "\u2068"}
+ISOLATE_CLOSER = "\u2069"
+SCRIPT_RANGES = {
+    "Cyrl": ((0x0400, 0x052F),),
+    "Grek": ((0x0370, 0x03FF),),
+    "Arab": ((0x0600, 0x06FF), (0x0750, 0x077F), (0x08A0, 0x08FF)),
+    "Hebr": ((0x0590, 0x05FF),),
+    "Hang": ((0xAC00, 0xD7AF),),
+    "Hani": ((0x3400, 0x4DBF), (0x4E00, 0x9FFF)),
+    "Jpan": ((0x3040, 0x30FF), (0x3400, 0x9FFF)),
+    "Latn": ((0x0041, 0x007A), (0x00C0, 0x024F)),
+}
+LANGUAGE_SCRIPTS = {
+    "ar": "Arab", "fa": "Arab", "ur": "Arab", "he": "Hebr",
+    "el": "Grek", "ru": "Cyrl", "uk": "Cyrl", "bg": "Cyrl",
+    "mk": "Cyrl", "ko": "Hang", "ja": "Jpan", "zh": "Hani",
+}
+
+
+def canonical_text(text: str) -> str:
+    """Normalize transport-only differences without hiding character corruption."""
+    return unicodedata.normalize("NFC", text.removeprefix("\ufeff").replace("\r\n", "\n").replace("\r", "\n"))
+
+
+def canonical_hash(text: str) -> str:
+    return hashlib.sha256(canonical_text(text).encode("utf-8")).hexdigest()
+
+
+def _b64encode(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _b64decode(data: str) -> bytes:
+    return base64.urlsafe_b64decode(data + "=" * (-len(data) % 4))
+
+
+def load_or_create_key(path: Path) -> bytes:
+    env_key = os.environ.get("BLUN_LANGUAGE_GUARD_KEY")
+    if env_key:
+        return hashlib.sha256(env_key.encode("utf-8")).digest()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        return path.read_bytes()
+    key = os.urandom(32)
+    temporary = path.with_suffix(".tmp")
+    temporary.write_bytes(key)
+    os.chmod(temporary, 0o600)
+    temporary.replace(path)
+    return key
+
+
+def issue_receipt(
+    source: str, target: str, language: str, key: bytes, ttl: int = 86400,
+    content_type: str = "prose", short_text_reviewed: bool = False,
+    purpose: str = "translation",
+) -> str:
+    now = int(time.time())
+    payload = {
+        "v": VERSION,
+        "source_sha256": canonical_hash(source),
+        "target_sha256": canonical_hash(target),
+        "language": language,
+        "purpose": purpose,
+        "content_type": content_type,
+        "short_text_reviewed": short_text_reviewed,
+        "iat": now,
+        "exp": now + max(60, min(ttl, 604800)),
+        "nonce": _b64encode(os.urandom(12)),
+    }
+    encoded = _b64encode(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode())
+    signature = _b64encode(hmac.new(key, encoded.encode(), hashlib.sha256).digest())
+    return f"blg6.{encoded}.{signature}"
+
+
+def verify_receipt(
+    token: str, source: str, target: str, language: str, key: bytes,
+    content_type: str = "prose", short_text_reviewed: bool = False,
+    purpose: str = "translation",
+) -> dict[str, Any]:
+    try:
+        prefix, encoded, signature = token.split(".")
+        expected = _b64encode(hmac.new(key, encoded.encode(), hashlib.sha256).digest())
+        if prefix != "blg6" or not hmac.compare_digest(signature, expected):
+            raise ValueError("invalid signature")
+        payload = json.loads(_b64decode(encoded))
+        checks = {
+            "source": payload.get("source_sha256") == canonical_hash(source),
+            "target": payload.get("target_sha256") == canonical_hash(target),
+            "language": payload.get("language") == language,
+            "purpose": payload.get("purpose") == purpose,
+            "content_type": payload.get("content_type") == content_type,
+            "short_text_reviewed": payload.get("short_text_reviewed") is short_text_reviewed,
+            "version": payload.get("v") == VERSION,
+            "not_expired": int(payload.get("exp", 0)) >= int(time.time()),
+        }
+        return {"valid": all(checks.values()), "checks": checks, "payload": payload}
+    except (ValueError, TypeError, KeyError, json.JSONDecodeError, UnicodeDecodeError) as error:
+        return {"valid": False, "error": str(error)}
+
+
+def bidi_findings(text: str) -> list[dict[str, str]]:
+    findings: list[dict[str, str]] = []
+    stack = 0
+    for character in text:
+        if character in DANGEROUS_BIDI:
+            findings.append({"code": "dangerous-bidi-control", "character": f"U+{ord(character):04X}"})
+        elif character in ISOLATE_OPENERS:
+            stack += 1
+        elif character == ISOLATE_CLOSER:
+            if stack == 0:
+                findings.append({"code": "unpaired-bidi-isolate", "character": "U+2069"})
+            else:
+                stack -= 1
+    if stack:
+        findings.append({"code": "unclosed-bidi-isolate", "count": str(stack)})
+    return findings
+
+
+def _in_script(character: str, script: str) -> bool:
+    point = ord(character)
+    return any(start <= point <= end for start, end in SCRIPT_RANGES.get(script, ()))
+
+
+def script_report(text: str, language: str) -> dict[str, Any]:
+    parts = language.replace("_", "-").split("-")
+    base = parts[0].casefold()
+    explicit = next((part.title() for part in parts[1:] if len(part) == 4), None)
+    expected = explicit or LANGUAGE_SCRIPTS.get(base)
+    if not expected:
+        return {"status": "not-evaluated", "reason": "no deterministic script expectation"}
+    letters = [c for c in text if unicodedata.category(c).startswith("L")]
+    if not letters:
+        return {"status": "fail", "expected_script": expected, "ratio": 0.0}
+    matching = sum(_in_script(c, expected) for c in letters)
+    ratio = matching / len(letters)
+    threshold = 0.45 if expected in {"Hani", "Jpan"} else 0.70
+    return {"status": "pass" if ratio >= threshold else "fail", "expected_script": expected, "ratio": round(ratio, 3)}
+
+
+def glossary_findings(target: str, glossary: dict[str, Any]) -> list[dict[str, str]]:
+    findings: list[dict[str, str]] = []
+    for source_term, rule in glossary.items():
+        if isinstance(rule, str):
+            pattern, flags = re.escape(rule), re.IGNORECASE
+        elif isinstance(rule, dict):
+            value = str(rule.get("target", ""))
+            pattern = value if rule.get("regex") else re.escape(value)
+            flags = 0 if rule.get("case_sensitive") else re.IGNORECASE
+        else:
+            continue
+        if pattern and not re.search(pattern, target, flags):
+            findings.append({"code": "missing-glossary-term", "source": source_term, "expected": pattern})
+    return findings